merge generic_rendering branch

5 files changed, 468 insertions, 241 deletions

diff --git a/repoze/bfg/tests/test_chameleon_text.py b/repoze/bfg/tests/test_chameleon_text.py
index cb30f489a..d9cefbd67 100644
--- a/repoze/bfg/tests/test_chameleon_text.py
+++ b/repoze/bfg/tests/test_chameleon_text.py
@@ -166,88 +166,33 @@ class GetRendererTests(Base, unittest.TestCase):
         from repoze.bfg.chameleon_text import get_renderer
         return get_renderer(name)
 
-    def test_nonabs_registered(self):
-        from repoze.bfg.threadlocal import get_current_registry
-        from repoze.bfg.chameleon_text import TextTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.txt')
-        utility = TextTemplateRenderer(minimal)
-        self._registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result, utility)
-        reg = get_current_registry()
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility)
-        
-    def test_nonabs_unregistered(self):
-        from repoze.bfg.threadlocal import get_current_registry
-        from repoze.bfg.chameleon_text import TextTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.txt')
-        reg = get_current_registry()
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), None)
-        utility = TextTemplateRenderer(minimal)
-        self._registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result, utility)
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility)
-
-    def test_explicit_registration(self):
-        from repoze.bfg.interfaces import ITemplateRenderer
+    def test_it(self):
+        from repoze.bfg.interfaces import IRendererFactory
         class Dummy:
             template = object()
-        utility = Dummy()
-        self._registerUtility(utility, ITemplateRenderer, name='foo')
+            def implementation(self): pass
+        renderer = Dummy()
+        def rf(spec):
+            return renderer
+        self._registerUtility(rf, IRendererFactory, name='foo')
         result = self._callFUT('foo')
-        self.failUnless(result is utility)
-
-class GetTemplateTests(unittest.TestCase, Base):
-    def setUp(self):
-        Base.setUp(self)
-
-    def tearDown(self):
-        Base.tearDown(self)
+        self.failUnless(result is renderer)
 
+class GetTemplateTests(Base, unittest.TestCase):
     def _callFUT(self, name):
         from repoze.bfg.chameleon_text import get_template
         return get_template(name)
 
-    def test_nonabs_registered(self):
-        from repoze.bfg.threadlocal import get_current_registry
-        from repoze.bfg.chameleon_text import TextTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.txt')
-        utility = TextTemplateRenderer(minimal)
-        self._registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result.filename, minimal)
-        reg = get_current_registry()
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility)
-        
-    def test_nonabs_unregistered(self):
-        from repoze.bfg.threadlocal import get_current_registry
-        from repoze.bfg.chameleon_text import TextTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.txt')
-        reg = get_current_registry()
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), None)
-        utility = TextTemplateRenderer(minimal)
-        self._registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result.filename, minimal)
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility)
-
-    def test_explicit_registration(self):
-        from repoze.bfg.interfaces import ITemplateRenderer
+    def test_it(self):
+        from repoze.bfg.interfaces import IRendererFactory
         class Dummy:
             template = object()
             def implementation(self):
                 return self.template
-        utility = Dummy()
-        self._registerUtility(utility, ITemplateRenderer, name='foo')
+        renderer = Dummy()
+        def rf(spec):
+            return renderer
+        self._registerUtility(rf, IRendererFactory, name='foo')
         result = self._callFUT('foo')
-        self.failUnless(result is utility.template)
-        
-        
-        
-
+        self.failUnless(result is renderer.template)
 
diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py
index 4ea5fc281..a0f01701a 100644
--- a/repoze/bfg/tests/test_chameleon_zpt.py
+++ b/repoze/bfg/tests/test_chameleon_zpt.py
@@ -128,6 +128,12 @@ class RenderTemplateTests(Base, unittest.TestCase):
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
 
 class RenderTemplateToResponseTests(Base, unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
     def _callFUT(self, name, **kw):
         from repoze.bfg.chameleon_zpt import render_template_to_response
         return render_template_to_response(name, **kw)
@@ -157,82 +163,32 @@ class GetRendererTests(Base, unittest.TestCase):
         from repoze.bfg.chameleon_zpt import get_renderer
         return get_renderer(name)
 
-    def test_nonabs_registered(self):
-        from repoze.bfg.threadlocal import get_current_registry
-        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.pt')
-        utility = ZPTTemplateRenderer(minimal)
-        self._registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result, utility)
-        reg = get_current_registry()
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility)
-        
-    def test_nonabs_unregistered(self):
-        from repoze.bfg.threadlocal import get_current_registry
-        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.pt')
-        reg = get_current_registry()
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), None)
-        utility = ZPTTemplateRenderer(minimal)
-        self._registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result, utility)
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility)
-
-    def test_explicit_registration(self):
-        from repoze.bfg.interfaces import ITemplateRenderer
+    def test_it(self):
+        from repoze.bfg.interfaces import IRendererFactory
         class Dummy:
             template = object()
-        utility = Dummy()
-        self._registerUtility(utility, ITemplateRenderer, name='foo')
+            def implementation(self): pass
+        renderer = Dummy()
+        def rf(spec):
+            return renderer
+        self._registerUtility(rf, IRendererFactory, name='foo')
         result = self._callFUT('foo')
-        self.failUnless(result is utility)
+        self.failUnless(result is renderer)
 
 class GetTemplateTests(Base, unittest.TestCase):
     def _callFUT(self, name):
         from repoze.bfg.chameleon_zpt import get_template
         return get_template(name)
 
-    def test_nonabs_registered(self):
-        from repoze.bfg.threadlocal import get_current_registry
-        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.pt')
-        utility = ZPTTemplateRenderer(minimal)
-        self._registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result.filename, minimal)
-        reg = get_current_registry()
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility)
-        
-    def test_nonabs_unregistered(self):
-        from repoze.bfg.threadlocal import get_current_registry
-        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.pt')
-        reg = get_current_registry()
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), None)
-        utility = ZPTTemplateRenderer(minimal)
-        self._registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result.filename, minimal)
-        self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility)
-
-    def test_explicit_registration(self):
-        from repoze.bfg.interfaces import ITemplateRenderer
+    def test_it(self):
+        from repoze.bfg.interfaces import IRendererFactory
         class Dummy:
             template = object()
             def implementation(self):
                 return self.template
-        utility = Dummy()
-        self._registerUtility(utility, ITemplateRenderer, name='foo')
+        renderer = Dummy()
+        def rf(spec):
+            return renderer
+        self._registerUtility(rf, IRendererFactory, name='foo')
         result = self._callFUT('foo')
-        self.failUnless(result is utility.template)
-        
-        
-        
-
-
+        self.failUnless(result is renderer.template)
diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py
index 25c5544b6..0cb8ff5e8 100644
--- a/repoze/bfg/tests/test_configuration.py
+++ b/repoze/bfg/tests/test_configuration.py
@@ -290,6 +290,15 @@ class ConfiguratorTests(unittest.TestCase):
         utility = reg.getUtility(IRequestFactory)
         self.assertEqual(utility, 'abc')
 
+    def test_setup_registry_renderer_globals_factory(self):
+        from repoze.bfg.registry import Registry
+        from repoze.bfg.interfaces import IRendererGlobalsFactory
+        reg = Registry()
+        config = self._makeOne(reg)
+        config.setup_registry(renderer_globals_factory='abc')
+        utility = reg.getUtility(IRendererGlobalsFactory)
+        self.assertEqual(utility, 'abc')
+
     def test_setup_registry_alternate_renderers(self):
         from repoze.bfg.registry import Registry
         from repoze.bfg.interfaces import IRendererFactory
@@ -300,6 +309,19 @@ class ConfiguratorTests(unittest.TestCase):
         self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'),
                          renderer)
 
+    def test_get_settings_nosettings(self):
+        from repoze.bfg.registry import Registry
+        reg = Registry()
+        config = self._makeOne(reg)
+        self.assertEqual(config.get_settings(), None)
+
+    def test_get_settings_withsettings(self):
+        from repoze.bfg.interfaces import ISettings
+        settings = {'a':1}
+        config = self._makeOne()
+        config.registry.registerUtility(settings, ISettings)
+        self.assertEqual(config.get_settings(), settings)
+
     def test_add_settings_settings_already_registered(self):
         from repoze.bfg.registry import Registry
         from repoze.bfg.interfaces import ISettings
@@ -2462,7 +2484,52 @@ class ConfiguratorTests(unittest.TestCase):
         config.unhook_zca(getSiteManager=gsm)
         self.assertEqual(gsm.unhooked, True)
 
+    def test_testing_add_renderer(self):
+        config = self._makeOne()
+        renderer = config.testing_add_renderer('templates/foo.pt')
+        from repoze.bfg.testing import DummyTemplateRenderer
+        self.failUnless(isinstance(renderer, DummyTemplateRenderer))
+        from repoze.bfg.renderers import render_to_response
+        # must provide request to pass in registry (this is a functest)
+        request = DummyRequest()
+        request.registry = config.registry
+        render_to_response('templates/foo.pt', foo=1, bar=2, request=request)
+        renderer.assert_(foo=1)
+        renderer.assert_(bar=2)
+        renderer.assert_(request=request)
+        
+    def test_testing_add_renderer_explicitrenderer(self):
+        config = self._makeOne()
+        class E(Exception): pass
+        def renderer(kw, system):
+            self.assertEqual(kw, {'foo':1, 'bar':2})
+            raise E
+        renderer = config.testing_add_renderer('templates/foo.pt', renderer)
+        from repoze.bfg.renderers import render_to_response
+        # must provide request to pass in registry (this is a functest)
+        request = DummyRequest()
+        request.registry = config.registry
+        try:
+            render_to_response(
+                'templates/foo.pt', foo=1, bar=2, request=request)
+        except E:
+            pass
+        else: # pragma: no cover
+            raise AssertionError 
 
+    def test_testing_add_template(self):
+        config = self._makeOne()
+        renderer = config.testing_add_template('templates/foo.pt')
+        from repoze.bfg.testing import DummyTemplateRenderer
+        self.failUnless(isinstance(renderer, DummyTemplateRenderer))
+        from repoze.bfg.renderers import render_to_response
+        # must provide request to pass in registry (this is a functest)
+        request = DummyRequest()
+        request.registry = config.registry
+        render_to_response('templates/foo.pt', foo=1, bar=2, request=request)
+        renderer.assert_(foo=1)
+        renderer.assert_(bar=2)
+        renderer.assert_(request=request)
 
 class Test__map_view(unittest.TestCase):
     def setUp(self):
@@ -2778,97 +2845,6 @@ class Test__map_view(unittest.TestCase):
         request = self._makeRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
 
-class Test_rendered_response(unittest.TestCase):
-    def setUp(self):
-        testing.setUp()
-
-    def tearDown(self):
-        testing.tearDown()
-
-    def _callFUT(self, renderer, response, view=None,
-                 context=None, request=None, renderer_name=None):
-        from repoze.bfg.configuration import rendered_response
-        if request is None:
-            request = DummyRequest()
-        return rendered_response(renderer, response, view,
-                                 context, request, renderer_name)
-
-    def _makeRenderer(self):
-        def renderer(*arg):
-            return 'Hello!'
-        return renderer
-
-    def test_is_response(self):
-        renderer = self._makeRenderer()
-        response = DummyResponse()
-        result = self._callFUT(renderer, response)
-        self.assertEqual(result, response)
-
-    def test_calls_renderer(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        result = self._callFUT(renderer, response)
-        self.assertEqual(result.body, 'Hello!')
-
-    def test_with_content_type(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_content_type':'text/nonsense'}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.content_type, 'text/nonsense')
-
-    def test_with_headerlist(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_headerlist':[('a', '1'), ('b', '2')]}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.headerlist,
-                         [('Content-Type', 'text/html; charset=UTF-8'),
-                          ('Content-Length', '6'),
-                          ('a', '1'),
-                          ('b', '2')])
-
-    def test_with_status(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_status':'406 You Lose'}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.status, '406 You Lose')
-
-    def test_with_charset(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_charset':'UTF-16'}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.charset, 'UTF-16')
-
-    def test_with_cache_for(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_cache_for':100}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.cache_control.max_age, 100)
-
-    def test_with_real_request(self):
-        # functional
-        from repoze.bfg.request import Request
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = Request({})
-        request.response_status = '406 You Lose'
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.status, '406 You Lose')
-
 class Test_decorate_view(unittest.TestCase):
     def _callFUT(self, wrapped, original):
         from repoze.bfg.configuration import decorate_view
diff --git a/repoze/bfg/tests/test_renderers.py b/repoze/bfg/tests/test_renderers.py
index 1f4df3556..8a8a578eb 100644
--- a/repoze/bfg/tests/test_renderers.py
+++ b/repoze/bfg/tests/test_renderers.py
@@ -120,21 +120,29 @@ class TestRendererFromName(unittest.TestCase):
     def tearDown(self):
         cleanUp()
         
-    def _callFUT(self, path):
+    def _callFUT(self, path, package=None):
         from repoze.bfg.renderers import renderer_from_name
-        return renderer_from_name(path)
+        return renderer_from_name(path, package)
 
     def test_it(self):
         from repoze.bfg.interfaces import IRendererFactory
         import os
         here = os.path.dirname(os.path.abspath(__file__))
         fixture = os.path.join(here, 'fixtures/minimal.pt')
-        renderer = {}
         def factory(path, **kw):
-            return renderer
+            return path
         testing.registerUtility(factory, IRendererFactory, name='.pt')
         result = self._callFUT(fixture)
-        self.assertEqual(result, renderer)
+        self.assertEqual(result, fixture)
+
+    def test_with_package(self):
+        from repoze.bfg.interfaces import IRendererFactory
+        def factory(path, **kw):
+            return path
+        testing.registerUtility(factory, IRendererFactory, name='.pt')
+        import repoze.bfg.tests
+        result = self._callFUT('fixtures/minimal.pt', repoze.bfg.tests)
+        self.assertEqual(result, 'repoze.bfg.tests:fixtures/minimal.pt')
 
     def test_it_no_renderer(self):
         self.assertRaises(ValueError, self._callFUT, 'foo')
@@ -199,6 +207,295 @@ class Test_string_renderer_factory(unittest.TestCase):
         renderer(None, {'request':request})
         self.assertEqual(request.response_content_type, 'text/mishmash')
 
+class Test_rendered_response(unittest.TestCase):
+    def setUp(self):
+        testing.setUp()
+        from zope.deprecation import __show__
+        __show__.off()
+
+    def tearDown(self):
+        testing.tearDown()
+        from zope.deprecation import __show__
+        __show__.on()
+
+    def _callFUT(self, renderer, response, view=None,
+                 context=None, request=None, renderer_name=None):
+        from repoze.bfg.renderers import rendered_response
+        if request is None:
+            request = testing.DummyRequest()
+        return rendered_response(renderer, response, view,
+                                 context, request, renderer_name)
+
+    def _makeRenderer(self):
+        def renderer(*arg):
+            return 'Hello!'
+        return renderer
+
+    def test_is_response(self):
+        renderer = self._makeRenderer()
+        response = DummyResponse()
+        result = self._callFUT(renderer, response)
+        self.assertEqual(result, response)
+
+    def test_calls_renderer(self):
+        renderer = self._makeRenderer()
+        response = {'a':'1'}
+        result = self._callFUT(renderer, response)
+        self.assertEqual(result.body, 'Hello!')
+
+class Test__make_response(unittest.TestCase):
+    def setUp(self):
+        self.config = testing.setUp()
+
+    def tearDown(self):
+        testing.tearDown()
+
+    def _callFUT(self, request, result):
+        from repoze.bfg.renderers import _make_response
+        return _make_response(request, result)
+
+    def test_with_content_type(self):
+        request = testing.DummyRequest()
+        attrs = {'response_content_type':'text/nonsense'}
+        request.__dict__.update(attrs)
+        response = self._callFUT(request, 'abc')
+        self.assertEqual(response.content_type, 'text/nonsense')
+        self.assertEqual(response.body, 'abc')
+
+    def test_with_headerlist(self):
+        request = testing.DummyRequest()
+        attrs = {'response_headerlist':[('a', '1'), ('b', '2')]}
+        request.__dict__.update(attrs)
+        response = self._callFUT(request, 'abc')
+        self.assertEqual(response.headerlist,
+                         [('Content-Type', 'text/html; charset=UTF-8'),
+                          ('Content-Length', '3'),
+                          ('a', '1'),
+                          ('b', '2')])
+        self.assertEqual(response.body, 'abc')
+
+    def test_with_status(self):
+        request = testing.DummyRequest()
+        attrs = {'response_status':'406 You Lose'}
+        request.__dict__.update(attrs)
+        response = self._callFUT(request, 'abc')
+        self.assertEqual(response.status, '406 You Lose')
+        self.assertEqual(response.body, 'abc')
+
+    def test_with_charset(self):
+        request = testing.DummyRequest()
+        attrs = {'response_charset':'UTF-16'}
+        request.__dict__.update(attrs)
+        response = self._callFUT(request, 'abc')
+        self.assertEqual(response.charset, 'UTF-16')
+
+    def test_with_cache_for(self):
+        request = testing.DummyRequest()
+        attrs = {'response_cache_for':100}
+        request.__dict__.update(attrs)
+        response = self._callFUT(request, 'abc')
+        self.assertEqual(response.cache_control.max_age, 100)
+
+    def test_with_alternate_response_factory(self):
+        from repoze.bfg.interfaces import IResponseFactory
+        class ResponseFactory(object):
+            def __init__(self, result):
+                self.result = result
+        self.config.registry.registerUtility(ResponseFactory, IResponseFactory)
+        request = testing.DummyRequest()
+        response = self._callFUT(request, 'abc')
+        self.assertEqual(response.__class__, ResponseFactory)
+        self.assertEqual(response.result, 'abc')
+
+    def test_with_real_request(self):
+        # functional
+        from repoze.bfg.request import Request
+        request = Request({})
+        attrs = {'response_status':'406 You Lose'}
+        request.__dict__.update(attrs)
+        response = self._callFUT(request, 'abc')
+        self.assertEqual(response.status, '406 You Lose')
+        self.assertEqual(response.body, 'abc')
+
+class Test__render(unittest.TestCase):
+    def setUp(self):
+        self.config = cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+
+    def _callFUT(self, renderer_name, request, values, system_values, renderer,
+                 package):
+        from repoze.bfg.renderers import _render
+        return _render(renderer_name, request, values, system_values, renderer,
+                       package)
+
+    def test_explicit_renderer(self):
+        def renderer(*arg):
+            return arg
+        result = self._callFUT(
+            'name', 'request', 'values', 'system_values', renderer, None)
+        self.assertEqual(result, ('values', 'system_values'))
+        
+    def test_request_has_registry(self):        
+        request = Dummy()
+        class DummyRegistry(object):
+            def queryUtility(self, iface):
+                self.queried = True
+                return None
+        reg = DummyRegistry()
+        request.registry = reg
+        def renderer(*arg):
+            return arg
+        result = self._callFUT(
+            'name', request, 'values', 'system_values', renderer, None)
+        self.assertEqual(result, ('values', 'system_values'))
+        self.failUnless(reg.queried)
+
+    def test_renderer_is_None(self):
+        from repoze.bfg.interfaces import IRendererFactory
+        def renderer(values, system):
+            return rf
+        def rf(spec):
+            return renderer
+        self.config.registry.registerUtility(rf, IRendererFactory, name='name')
+        result = self._callFUT(
+            'name', 'request', 'values', 'system_values', None, None)
+        self.assertEqual(result, rf)
+
+    def test_system_values_is_None(self):
+        def renderer(*arg):
+            return arg
+        request = Dummy()
+        context = Dummy()
+        request.context = context
+        result = self._callFUT(
+            'name', request, 'values', None, renderer, None)
+        system = {'request':request, 'context':context,
+                  'renderer_name':'name', 'view':None}
+        self.assertEqual(result, ('values', system))
+
+    def test_renderer_globals_factory_active(self):
+        from repoze.bfg.interfaces import IRendererGlobalsFactory
+        def rg(system):
+            return {'a':1}
+        self.config.registry.registerUtility(rg, IRendererGlobalsFactory)
+        def renderer(*arg):
+            return arg
+        result = self._callFUT(
+            'name', 'request', 'values', {'a':2}, renderer, None)
+        self.assertEqual(result, ('values', {'a':1}))
+
+class Test__render_to_response(unittest.TestCase):
+    def setUp(self):
+        self.config = cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+
+    def _callFUT(self, renderer_name, request, values, system_values, renderer,
+                 package):
+        from repoze.bfg.renderers import _render_to_response
+        return _render_to_response(
+            renderer_name, request, values, system_values, renderer,
+            package)
+
+    def test_it(self):
+        def renderer(*arg):
+            return 'hello'
+        request = Dummy()
+        result = self._callFUT(
+            'name', request, 'values', 'system_values', renderer, None)
+        self.assertEqual(result.body, 'hello')
+
+class Test_render(unittest.TestCase):
+    def setUp(self):
+        self.config = testing.setUp()
+
+    def tearDown(self):
+        testing.tearDown()
+
+    def _callFUT(self, renderer_name, **kw):
+        from repoze.bfg.renderers import render
+        return render(renderer_name, **kw)
+
+    def test_it_no_request(self):
+        renderer = self.config.testing_add_renderer(
+            'repoze.bfg.tests:abc/def.pt')
+        renderer.string_response = 'abc'
+        result = self._callFUT('abc/def.pt', a=1)
+        self.assertEqual(result, 'abc')
+        renderer.assert_(a=1)
+        renderer.assert_(request=None)
+        
+    def test_it_with_request(self):
+        renderer = self.config.testing_add_renderer(
+            'repoze.bfg.tests:abc/def.pt')
+        renderer.string_response = 'abc'
+        request = testing.DummyRequest()
+        result = self._callFUT('abc/def.pt',
+                               a=1, request=request)
+        self.assertEqual(result, 'abc')
+        renderer.assert_(a=1)
+        renderer.assert_(request=request)
+
+class Test_render_to_response(unittest.TestCase):
+    def setUp(self):
+        self.config = testing.setUp()
+
+    def tearDown(self):
+        testing.tearDown()
+
+    def _callFUT(self, renderer_name, **kw):
+        from repoze.bfg.renderers import render_to_response
+        return render_to_response(renderer_name, **kw)
+
+    def test_it_no_request(self):
+        renderer = self.config.testing_add_renderer(
+            'repoze.bfg.tests:abc/def.pt')
+        renderer.string_response = 'abc'
+        response = self._callFUT('abc/def.pt', a=1)
+        self.assertEqual(response.body, 'abc')
+        renderer.assert_(a=1)
+        renderer.assert_(request=None)
+        
+    def test_it_with_request(self):
+        renderer = self.config.testing_add_renderer(
+            'repoze.bfg.tests:abc/def.pt')
+        renderer.string_response = 'abc'
+        request = testing.DummyRequest()
+        response = self._callFUT('abc/def.pt',
+                               a=1, request=request)
+        self.assertEqual(response.body, 'abc')
+        renderer.assert_(a=1)
+        renderer.assert_(request=request)
+    
+class Test_get_renderer(unittest.TestCase):
+    def setUp(self):
+        self.config = testing.setUp()
+
+    def tearDown(self):
+        testing.tearDown()
+
+    def _callFUT(self, renderer_name, **kw):
+        from repoze.bfg.renderers import get_renderer
+        return get_renderer(renderer_name)
+
+    def test_it(self):
+        renderer = self.config.testing_add_renderer(
+            'repoze.bfg.tests:abc/def.pt')
+        result = self._callFUT('abc/def.pt')
+        self.assertEqual(result, renderer)
+
+class Dummy:
+    pass
+
+class DummyResponse:
+    status = '200 OK'
+    headerlist = ()
+    app_iter = ()
+    body = ''
+
 class DummyFactory:
     def __init__(self, renderer):
         self.renderer = renderer
diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py
index 1b3d731fa..fc3bd7c9e 100644
--- a/repoze/bfg/tests/test_testing.py
+++ b/repoze/bfg/tests/test_testing.py
@@ -66,18 +66,18 @@ class Test_registerTemplateRenderer(TestBase):
         renderer = testing.registerTemplateRenderer('templates/foo')
         from repoze.bfg.testing import DummyTemplateRenderer
         self.failUnless(isinstance(renderer, DummyTemplateRenderer))
-        from repoze.bfg.chameleon_zpt import render_template_to_response
-        render_template_to_response('templates/foo', foo=1, bar=2)
-        self.assertEqual(dict(foo=1, bar=2), renderer._received)
+        from repoze.bfg.renderers import render_to_response
+        render_to_response('templates/foo', foo=1, bar=2)
+        renderer.assert_(foo=1)
+        renderer.assert_(bar=2)
 
     def test_registerTemplateRenderer_explicitrenderer(self):
         from repoze.bfg import testing
         def renderer(kw, system):
-            raise ValueError
+            self.assertEqual(kw, {'foo':1, 'bar':2})
         renderer = testing.registerTemplateRenderer('templates/foo', renderer)
-        from repoze.bfg.chameleon_zpt import render_template_to_response
-        self.assertRaises(ValueError, render_template_to_response,
-                          'templates/foo', foo=1, bar=2)
+        from repoze.bfg.renderers import render_to_response
+        render_to_response('templates/foo', foo=1, bar=2)
 
 class Test_registerEventListener(TestBase):
     def test_registerEventListener_single(self):
@@ -526,8 +526,8 @@ class TestDummyTemplateRenderer(unittest.TestCase):
         renderer = self._makeOne()
         impl = renderer.implementation()
         impl(a=1, b=2)
-        self.assertEqual(renderer._received['a'], 1)
-        self.assertEqual(renderer._received['b'], 2)
+        self.assertEqual(renderer._implementation._received['a'], 1)
+        self.assertEqual(renderer._implementation._received['b'], 2)
 
     def test_getattr(self):
         renderer = self._makeOne()
@@ -666,6 +666,59 @@ class Test_tearDown(unittest.TestCase):
             getSiteManager.reset()
             manager.clear()
 
+class TestDummyRendererFactory(unittest.TestCase):
+    def _makeOne(self, name, factory):
+        from repoze.bfg.testing import DummyRendererFactory
+        return DummyRendererFactory(name, factory)
+
+    def test_add_no_colon(self):
+        f = self._makeOne('name', None)
+        f.add('spec', 'renderer')
+        self.assertEqual(f.renderers['spec'], 'renderer')
+
+    def test_add_with_colon(self):
+        f = self._makeOne('name', None)
+        f.add('spec:spec2', 'renderer')
+        self.assertEqual(f.renderers['spec:spec2'], 'renderer')
+        self.assertEqual(f.renderers['spec2'], 'renderer')
+
+    def test_call(self):
+        f = self._makeOne('name', None)
+        f.renderers['spec'] = 'renderer'
+        self.assertEqual(f('spec'), 'renderer')
+        
+    def test_call2(self):
+        f = self._makeOne('name', None)
+        f.renderers['spec'] = 'renderer'
+        self.assertEqual(f('spec:spec'), 'renderer')
+
+    def test_call3(self):
+        def factory(spec):
+            return 'renderer'
+        f = self._makeOne('name', factory)
+        self.assertEqual(f('spec'), 'renderer')
+
+    def test_call_miss(self):
+        f = self._makeOne('name', None)
+        self.assertRaises(KeyError, f, 'spec')
+
+class TestMockTemplate(unittest.TestCase):
+    def _makeOne(self, response):
+        from repoze.bfg.testing import MockTemplate
+        return MockTemplate(response)
+
+    def test_getattr(self):
+        template = self._makeOne(None)
+        self.assertEqual(template.foo, template)
+
+    def test_getitem(self):
+        template = self._makeOne(None)
+        self.assertEqual(template['foo'], template)
+
+    def test_call(self):
+        template = self._makeOne('123')
+        self.assertEqual(template(), '123')
+
 from zope.interface import Interface
 from zope.interface import implements