Remove Chameleon specific renderer tests

1 files changed, 9 insertions, 330 deletions

diff --git a/pyramid/tests/test_renderers.py b/pyramid/tests/test_renderers.py
index befb714bd..42c267fd8 100644
--- a/pyramid/tests/test_renderers.py
+++ b/pyramid/tests/test_renderers.py
@@ -10,18 +10,18 @@ class TestTemplateRendererFactory(unittest.TestCase):
 
     def tearDown(self):
         cleanUp()
-        
+
     def _callFUT(self, info, impl):
         from pyramid.renderers import template_renderer_factory
         return template_renderer_factory(info, impl)
 
     def test_lookup_found(self):
-        from pyramid.interfaces import IChameleonLookup
+        from pyramid.interfaces import IJSONAdapter
         L = []
         def dummy(info):
             L.append(info)
             return True
-        self.config.registry.registerUtility(dummy, IChameleonLookup,
+        self.config.registry.registerUtility(dummy, IJSONAdapter,
                                              name='abc')
         class DummyInfo(object):
             pass
@@ -49,327 +49,6 @@ class TestTemplateRendererFactory(unittest.TestCase):
         result = self._callFUT(info, None)
         self.assertTrue(result is renderer)
 
-class TestChameleonRendererLookup(unittest.TestCase):
-    def setUp(self):
-        self.config = testing.setUp()
-
-    def tearDown(self):
-        testing.tearDown()
-        
-    def _makeOne(self, impl):
-        from pyramid.renderers import ChameleonRendererLookup
-        return ChameleonRendererLookup(impl, self.config.registry)
-
-    def _registerTemplateRenderer(self, renderer, name):
-        from pyramid.interfaces import ITemplateRenderer
-        self.config.registry.registerUtility(
-            renderer, ITemplateRenderer, name=name)
-
-    def test_get_spec_not_abspath_no_colon_no_package(self):
-        lookup = self._makeOne(None)
-        result = lookup.get_spec('foo', None)
-        self.assertEqual(result, 'foo')
-
-    def test_get_spec_not_abspath_no_colon_with_package(self):
-        from pyramid import tests
-        lookup = self._makeOne(None)
-        result = lookup.get_spec('foo', tests)
-        self.assertEqual(result, 'pyramid.tests:foo')
-
-    def test_get_spec_not_abspath_with_colon_no_package(self):
-        lookup = self._makeOne(None)
-        result = lookup.get_spec('fudge:foo', None)
-        self.assertEqual(result, 'fudge:foo')
-
-    def test_get_spec_not_abspath_with_colon_with_package(self):
-        from pyramid import tests
-        lookup = self._makeOne(None)
-        result = lookup.get_spec('fudge:foo', tests)
-        self.assertEqual(result, 'fudge:foo')
-
-    def test_get_spec_is_abspath_no_colon_no_package(self):
-        import os
-        lookup = self._makeOne(None)
-        spec = os.path.abspath(__file__)
-        result = lookup.get_spec(spec, None)
-        self.assertEqual(result, spec)
-
-    def test_get_spec_is_abspath_no_colon_with_path_in_package(self):
-        from pyramid import tests
-        import os
-        lookup = self._makeOne(None)
-        f = __file__
-        spec = os.path.abspath(f)
-        result = lookup.get_spec(spec, tests)
-        self.assertEqual(result, 'pyramid.tests:%s' % os.path.split(f)[-1])
-
-    def test_get_spec_is_abspath_no_colon_with_path_outside_package(self):
-        import venusian # used only because it's outside of pyramid.tests
-        import os
-        lookup = self._makeOne(None)
-        f = __file__
-        spec = os.path.abspath(f)
-        result = lookup.get_spec(spec, venusian)
-        self.assertEqual(result, spec)
-
-    def test_get_spec_is_abspath_with_colon_no_package(self):
-        import os
-        lookup = self._makeOne(None)
-        spec = os.path.join(os.path.abspath(__file__), ':foo')
-        result = lookup.get_spec(spec, None)
-        self.assertEqual(result, spec)
-
-    def test_get_spec_is_abspath_with_colon_with_path_in_package(self):
-        from pyramid import tests
-        import os
-        lookup = self._makeOne(None)
-        f = os.path.abspath(__file__)
-        spec = os.path.join(f, ':foo')
-        result = lookup.get_spec(spec, tests)
-        tail = spec.split(os.sep)[-2:]
-        self.assertEqual(result, 'pyramid.tests:%s/%s' % tuple(tail))
-
-    def test_get_spec_is_abspath_with_colon_with_path_outside_package(self):
-        import venusian # used only because it's outside of pyramid.tests
-        import os
-        lookup = self._makeOne(None)
-        spec = os.path.join(os.path.abspath(__file__), ':foo')
-        result = lookup.get_spec(spec, venusian)
-        self.assertEqual(result, spec)
-
-    def test_translate(self):
-        from pyramid.interfaces import IChameleonTranslate
-        def t(): pass
-        self.config.registry.registerUtility(t, IChameleonTranslate)
-        lookup = self._makeOne(None)
-        self.assertEqual(lookup.translate, t)
-
-    def test_debug_settings_None(self):
-        self.config.registry.settings = None
-        lookup = self._makeOne(None)
-        self.assertEqual(lookup.debug, False)
-
-    def test_debug_settings_not_None(self):
-        self.config.registry.settings = {'debug_templates':True}
-        lookup = self._makeOne(None)
-        self.assertEqual(lookup.debug, True)
-
-    def test_auto_reload_settings_None(self):
-        self.config.registry.settings = None
-        lookup = self._makeOne(None)
-        self.assertEqual(lookup.auto_reload, False)
-
-    def test_auto_reload_settings_not_None(self):
-        self.config.registry.settings = {'reload_templates':True}
-        lookup = self._makeOne(None)
-        self.assertEqual(lookup.auto_reload, True)
-
-    def test___call__abspath_path_notexists(self):
-        abspath = '/wont/exist'
-        self._registerTemplateRenderer({}, abspath)
-        info = DummyRendererInfo({
-            'name':abspath,
-            'package':None,
-            'registry':self.config.registry,
-            'settings':{},
-            'type':'type',
-            })
-        lookup = self._makeOne(None)
-        self.assertRaises(ValueError, lookup.__call__, info)
-
-    def test___call__abspath_alreadyregistered(self):
-        import os
-        abspath = os.path.abspath(__file__)
-        renderer = {}
-        self._registerTemplateRenderer(renderer, abspath)
-        info = DummyRendererInfo({
-            'name':abspath,
-            'package':None,
-            'registry':self.config.registry,
-            'settings':{},
-            'type':'type',
-            })
-        lookup = self._makeOne(None)
-        result = lookup(info)
-        self.assertTrue(result is renderer)
-
-    def test___call__abspath_notyetregistered(self):
-        import os
-        abspath = os.path.abspath(__file__)
-        renderer = {}
-        factory = DummyFactory(renderer)
-        info = DummyRendererInfo({
-            'name':abspath,
-            'package':None,
-            'registry':self.config.registry,
-            'settings':{},
-            'type':'type',
-            })
-        lookup = self._makeOne(factory)
-        result = lookup(info)
-        self.assertEqual(result, renderer)
-
-    def test___call__relpath_path_registered(self):
-        renderer = {}
-        spec = 'foo/bar'
-        self._registerTemplateRenderer(renderer, spec)
-        info = DummyRendererInfo({
-            'name':spec,
-            'package':None,
-            'registry':self.config.registry,
-            'settings':{},
-            'type':'type',
-            })
-        lookup = self._makeOne(None)
-        result = lookup(info)
-        self.assertTrue(renderer is result)
-
-    def test___call__relpath_has_package_registered(self):
-        renderer = {}
-        import pyramid.tests
-        spec = 'bar/baz'
-        self._registerTemplateRenderer(renderer, 'pyramid.tests:bar/baz')
-        info = DummyRendererInfo({
-            'name':spec,
-            'package':pyramid.tests,
-            'registry':self.config.registry,
-            'settings':{},
-            'type':'type',
-            })
-        lookup = self._makeOne(None)
-        result = lookup(info)
-        self.assertTrue(renderer is result)
-
-    def test___call__spec_notfound(self):
-        spec = 'pyramid.tests:wont/exist'
-        info = DummyRendererInfo({
-            'name':spec,
-            'package':None,
-            'registry':self.config.registry,
-            'settings':{},
-            'type':'type',
-            })
-        lookup = self._makeOne(None)
-        self.assertRaises(ValueError, lookup.__call__, info)
-
-    def test___call__spec_alreadyregistered(self):
-        from pyramid import tests
-        module_name = tests.__name__
-        relpath = 'test_renderers.py'
-        spec = '%s:%s' % (module_name, relpath)
-        info = DummyRendererInfo({
-            'name':spec,
-            'package':None,
-            'registry':self.config.registry,
-            'settings':{},
-            'type':'type',
-            })
-        renderer = {}
-        self._registerTemplateRenderer(renderer, spec)
-        lookup = self._makeOne(None)
-        result = lookup(info)
-        self.assertTrue(result is renderer)
-
-    def test___call__spec_notyetregistered(self):
-        import os
-        from pyramid import tests
-        module_name = tests.__name__
-        relpath = 'test_renderers.py'
-        renderer = {}
-        factory = DummyFactory(renderer)
-        spec = '%s:%s' % (module_name, relpath)
-        info = DummyRendererInfo({
-            'name':spec,
-            'package':None,
-            'registry':self.config.registry,
-            'settings':{},
-            'type':'type',
-            })
-        lookup = self._makeOne(factory)
-        result = lookup(info)
-        self.assertTrue(result is renderer)
-        path = os.path.abspath(__file__).split('$')[0] # jython
-        if path.endswith('.pyc'): # pragma: no cover
-            path = path[:-1]
-        self.assertTrue(factory.path.startswith(path))
-        self.assertEqual(factory.kw, {'macro':None})
-
-    def test___call__spec_withmacro(self):
-        from pyramid.interfaces import ITemplateRenderer
-        import os
-        from pyramid import tests
-        module_name = tests.__name__
-        relpath = 'fixtures/withmacro#foo.pt'
-        renderer = {}
-        factory = DummyFactory(renderer)
-        spec = '%s:%s' % (module_name, relpath)
-        reg = self.config.registry
-        info = DummyRendererInfo({
-            'name':spec,
-            'package':None,
-            'registry':reg,
-            'settings':{},
-            'type':'type',
-            })
-        lookup = self._makeOne(factory)
-        result = lookup(info)
-        self.assertTrue(result is renderer)
-        path = os.path.join(
-            os.path.dirname(os.path.abspath(__file__)),
-            'fixtures',
-            'withmacro.pt')
-        self.assertTrue(factory.path.startswith(path))
-        self.assertEqual(factory.kw, {'macro':'foo'})
-        self.assertTrue(
-            reg.getUtility(ITemplateRenderer, name=spec) is renderer
-            )
-
-    def test___call__reload_assets_true(self):
-        import pyramid.tests
-        from pyramid.interfaces import ISettings
-        from pyramid.interfaces import ITemplateRenderer
-        settings = {'reload_assets':True}
-        self.config.registry.registerUtility(settings, ISettings)
-        renderer = {}
-        factory = DummyFactory(renderer)
-        spec = 'test_renderers.py'
-        reg = self.config.registry
-        info = DummyRendererInfo({
-            'name':spec,
-            'package':pyramid.tests,
-            'registry':reg,
-            'settings':settings,
-            'type':'type',
-            })
-        lookup = self._makeOne(factory)
-        result = lookup(info)
-        self.assertTrue(result is renderer)
-        spec = '%s:%s' % ('pyramid.tests', 'test_renderers.py')
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, name=spec),
-                         None)
-
-    def test___call__reload_assets_false(self):
-        import pyramid.tests
-        from pyramid.interfaces import ITemplateRenderer
-        settings = {'reload_assets':False}
-        renderer = {}
-        factory = DummyFactory(renderer)
-        spec = 'test_renderers.py'
-        reg = self.config.registry
-        info = DummyRendererInfo({
-            'name':spec,
-            'package':pyramid.tests,
-            'registry':reg,
-            'settings':settings,
-            'type':'type',
-            })
-        lookup = self._makeOne(factory)
-        result = lookup(info)
-        self.assertTrue(result is renderer)
-        spec = '%s:%s' % ('pyramid.tests', 'test_renderers.py')
-        self.assertNotEqual(reg.queryUtility(ITemplateRenderer, name=spec),
-                            None)
-
 class TestJSON(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -470,7 +149,7 @@ class Test_string_renderer_factory(unittest.TestCase):
         value = text_('La Pe\xc3\xb1a', 'utf-8')
         result = renderer(value, {})
         self.assertEqual(result, value)
-                          
+
     def test_it_str(self):
         renderer = self._callFUT(None)
         value = 'La Pe\xc3\xb1a'
@@ -680,7 +359,7 @@ class TestRendererHelper(unittest.TestCase):
         helper = self._makeOne('loo.foo')
         response = helper._make_response(None, request)
         self.assertEqual(response.body, b'abc')
-        
+
     def test__make_response_with_content_type(self):
         from pyramid.response import Response
         request = testing.DummyRequest()
@@ -873,7 +552,7 @@ class Test_render(unittest.TestCase):
         self.assertEqual(result, 'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=None)
-        
+
     def test_it_with_request(self):
         renderer = self.config.testing_add_renderer(
             'pyramid.tests:abc/def.pt')
@@ -917,7 +596,7 @@ class Test_render_to_response(unittest.TestCase):
         self.assertEqual(response.body, b'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=None)
-        
+
     def test_it_with_request(self):
         renderer = self.config.testing_add_renderer(
             'pyramid.tests:abc/def.pt')
@@ -1007,9 +686,9 @@ class DummyFactory:
         self.path = path
         self.kw = kw
         return self.renderer
-    
+
 
 class DummyRendererInfo(object):
     def __init__(self, kw):
         self.__dict__.update(kw)
-        
+