svn merge -r9909:HEAD $REPOZE_SVN/repoze.bfg/branches/rendererhelper

4 files changed, 165 insertions, 143 deletions

diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py
index 58a4a2eda..159429a06 100644
--- a/repoze/bfg/tests/test_configuration.py
+++ b/repoze/bfg/tests/test_configuration.py
@@ -1989,14 +1989,6 @@ class ConfiguratorTests(unittest.TestCase):
         self.assertEqual(config.registry.getUtility(ITranslationDirectories),
                          [locale])
 
-    def test__renderer_from_name_default_renderer(self):
-        from repoze.bfg.interfaces import IRendererFactory
-        config = self._makeOne()
-        factory = lambda *arg: 'OK'
-        config.registry.registerUtility(factory, IRendererFactory)
-        result = config._renderer_from_name(None)
-        self.assertEqual(result, 'OK')
-
     def test_derive_view_function(self):
         def view(request):
             return 'OK'
@@ -2571,7 +2563,8 @@ class ConfiguratorTests(unittest.TestCase):
         # 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)
+        render_to_response(
+            'templates/foo.pt', {'foo':1, 'bar':2}, request=request)
         renderer.assert_(foo=1)
         renderer.assert_(bar=2)
         renderer.assert_(request=request)
@@ -2589,7 +2582,7 @@ class ConfiguratorTests(unittest.TestCase):
         request.registry = config.registry
         try:
             render_to_response(
-                'templates/foo.pt', foo=1, bar=2, request=request)
+                'templates/foo.pt', {'foo':1, 'bar':2}, request=request)
         except E:
             pass
         else: # pragma: no cover
@@ -2604,7 +2597,8 @@ class ConfiguratorTests(unittest.TestCase):
         # 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)
+        render_to_response('templates/foo.pt', dict(foo=1, bar=2),
+                           request=request)
         renderer.assert_(foo=1)
         renderer.assert_(bar=2)
         renderer.assert_(request=request)
@@ -2613,22 +2607,25 @@ class Test__map_view(unittest.TestCase):
     def setUp(self):
         from repoze.bfg.registry import Registry
         self.registry = Registry()
+        testing.setUp(registry=self.registry)
 
     def tearDown(self):
         del self.registry
+        testing.tearDown()
         
-    def _registerRenderer(self, name='.txt'):
+    def _registerRenderer(self, typ='.txt'):
         from repoze.bfg.interfaces import IRendererFactory
         from repoze.bfg.interfaces import ITemplateRenderer
         from zope.interface import implements
         class Renderer:
             implements(ITemplateRenderer)
+            spec = 'abc' + typ
             def __init__(self, path):
                 self.__class__.path = path
             def __call__(self, *arg):
                 return 'Hello!'
-        self.registry.registerUtility(Renderer, IRendererFactory, name=name)
-        return Renderer(name)
+        self.registry.registerUtility(Renderer, IRendererFactory, name=typ)
+        return Renderer
 
     def _makeRequest(self):
         request = DummyRequest()
@@ -2656,7 +2653,8 @@ class Test__map_view(unittest.TestCase):
     def test__map_view_as_function_with_attr_and_renderer(self):
         renderer = self._registerRenderer()
         view = lambda *arg: 'OK'
-        result = self._callFUT(view, attr='__name__', renderer=renderer)
+        result = self._callFUT(view, attr='__name__',
+                               renderer_name=renderer.spec)
         self.failIf(result is view)
         self.assertRaises(TypeError, result, None, None)
         
@@ -2714,7 +2712,7 @@ class Test__map_view(unittest.TestCase):
                 pass
             def index(self):
                 return {'a':'1'}
-        result = self._callFUT(view, attr='index', renderer = renderer)
+        result = self._callFUT(view, attr='index', renderer_name=renderer.spec)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
@@ -2755,7 +2753,7 @@ class Test__map_view(unittest.TestCase):
                 pass
             def index(self):
                 return {'a':'1'}
-        result = self._callFUT(view, attr='index', renderer = renderer)
+        result = self._callFUT(view, attr='index', renderer_name=renderer.spec)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
@@ -2796,7 +2794,7 @@ class Test__map_view(unittest.TestCase):
                 pass
             def index(self):
                 return {'a':'1'}
-        result = self._callFUT(view, attr='index', renderer = renderer)
+        result = self._callFUT(view, attr='index', renderer_name=renderer.spec)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
@@ -2837,7 +2835,7 @@ class Test__map_view(unittest.TestCase):
                 pass
             def index(self):
                 return {'a':'1'}
-        result = self._callFUT(view, attr='index', renderer = renderer)
+        result = self._callFUT(view, attr='index', renderer_name=renderer.spec)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
@@ -2869,7 +2867,7 @@ class Test__map_view(unittest.TestCase):
             def index(self, context, request):
                 return {'a':'1'}
         view = View()
-        result = self._callFUT(view, attr='index', renderer=renderer)
+        result = self._callFUT(view, attr='index', renderer_name=renderer.spec)
         self.failIf(result is view)
         request = self._makeRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
@@ -2904,7 +2902,7 @@ class Test__map_view(unittest.TestCase):
             def index(self, request):
                 return {'a':'1'}
         view = View()
-        result = self._callFUT(view, attr='index', renderer = renderer)
+        result = self._callFUT(view, attr='index', renderer_name=renderer.spec)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
@@ -2916,12 +2914,37 @@ class Test__map_view(unittest.TestCase):
         renderer = self._registerRenderer()
         def view(context, request):
             return {'a':'1'}
-        result = self._callFUT(view, renderer=renderer)
+        result = self._callFUT(view, renderer_name=renderer.spec)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test__map_view_with_registry(self):
+        renderer = self._registerRenderer()
+        def view(context, request):
+            return {'a':'1'}
+        result = self._callFUT(view, renderer_name=renderer.spec,
+                               registry=self.registry)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test__map_view_with_package(self):
+        renderer = self._registerRenderer()
+        def view(context, request):
+            return {'a':'1'}
+        result = self._callFUT(view, renderer_name=renderer.spec,
+                               package='repoze.bfg')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         request = self._makeRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
+        self.assertEqual(renderer.path, 'repoze.bfg:abc.txt')
 
 class Test_decorate_view(unittest.TestCase):
     def _callFUT(self, wrapped, original):
diff --git a/repoze/bfg/tests/test_renderers.py b/repoze/bfg/tests/test_renderers.py
index 8a8a578eb..264b4a547 100644
--- a/repoze/bfg/tests/test_renderers.py
+++ b/repoze/bfg/tests/test_renderers.py
@@ -243,30 +243,106 @@ class Test_rendered_response(unittest.TestCase):
         result = self._callFUT(renderer, response)
         self.assertEqual(result.body, 'Hello!')
 
-class Test__make_response(unittest.TestCase):
+
+class TestRendererHelper(unittest.TestCase):
     def setUp(self):
-        self.config = testing.setUp()
+        self.config = cleanUp()
 
     def tearDown(self):
-        testing.tearDown()
+        cleanUp()
+
+    def _makeOne(self, *arg, **kw):
+        from repoze.bfg.renderers import RendererHelper
+        return RendererHelper(*arg, **kw)
+
+    def _registerRendererFactory(self):
+        from repoze.bfg.interfaces import IRendererFactory
+        def renderer(*arg):
+            def respond(*arg):
+                return arg
+            return respond
+        self.config.registry.registerUtility(renderer, IRendererFactory,
+                                             name='.foo')
+        return renderer
 
-    def _callFUT(self, request, result):
-        from repoze.bfg.renderers import _make_response
-        return _make_response(request, result)
+    def test_resolve_spec_path_is_None(self):
+        helper = self._makeOne('loo.foo')
+        result = helper.resolve_spec(None)
+        self.assertEqual(result, None)
 
-    def test_with_content_type(self):
+    def test_resolve_spec_package_is_None(self):
+        helper = self._makeOne('loo.foo')
+        result = helper.resolve_spec('/foo/bar')
+        self.assertEqual(result, '/foo/bar')
+
+    def test_resolve_spec_absolute(self):
+        helper = self._makeOne('loo.foo')
+        result = helper.resolve_spec('repoze.bfg:flub')
+        self.assertEqual(result, 'repoze.bfg:flub')
+
+    def test_resolve_spec_relative(self):
+        helper = self._makeOne('loo.foo', package='repoze.bfg')
+        result = helper.resolve_spec('flub')
+        self.assertEqual(result, 'repoze.bfg:flub')
+
+    def test_render_to_response(self):
+        self._registerRendererFactory()
+        request = Dummy()
+        helper = self._makeOne('loo.foo')
+        response = helper.render_to_response('values', 'system_values',
+                                             request=request)
+        self.assertEqual(response.body, ('values', 'system_values'))
+
+    def test_render_explicit_registry(self):
+        factory = self._registerRendererFactory()
+        class DummyRegistry(object):
+            def __init__(self):
+                self.responses = [factory, lambda *arg: {}]
+            def queryUtility(self, iface, name=None):
+                self.queried = True
+                return self.responses.pop(0)
+        reg = DummyRegistry()
+        helper = self._makeOne('loo.foo', registry=reg)
+        result = helper.render('value', {})
+        self.assertEqual(result, ('value', {}))
+        self.failUnless(reg.queried)
+
+    def test_render_system_values_is_None(self):
+        self._registerRendererFactory()
+        request = Dummy()
+        context = Dummy()
+        request.context = context
+        helper = self._makeOne('loo.foo')
+        result = helper.render('values', None, request=request)
+        system = {'request':request, 'context':context,
+                  'renderer_name':'loo.foo', 'view':None}
+        self.assertEqual(result, ('values', system))
+
+    def test_render_renderer_globals_factory_active(self):
+        self._registerRendererFactory()
+        from repoze.bfg.interfaces import IRendererGlobalsFactory
+        def rg(system):
+            return {'a':1}
+        self.config.registry.registerUtility(rg, IRendererGlobalsFactory)
+        helper = self._makeOne('loo.foo')
+        result = helper.render('values', None)
+        self.assertEqual(result[1]['a'], 1)
+
+    def test__make_response_with_content_type(self):
         request = testing.DummyRequest()
         attrs = {'response_content_type':'text/nonsense'}
         request.__dict__.update(attrs)
-        response = self._callFUT(request, 'abc')
+        helper = self._makeOne('loo.foo')
+        response = helper._make_response('abc', request)
         self.assertEqual(response.content_type, 'text/nonsense')
         self.assertEqual(response.body, 'abc')
 
-    def test_with_headerlist(self):
+    def test__make_response_with_headerlist(self):
         request = testing.DummyRequest()
         attrs = {'response_headerlist':[('a', '1'), ('b', '2')]}
         request.__dict__.update(attrs)
-        response = self._callFUT(request, 'abc')
+        helper = self._makeOne('loo.foo')
+        response = helper._make_response('abc', request)
         self.assertEqual(response.headerlist,
                          [('Content-Type', 'text/html; charset=UTF-8'),
                           ('Content-Length', '3'),
@@ -274,26 +350,29 @@ class Test__make_response(unittest.TestCase):
                           ('b', '2')])
         self.assertEqual(response.body, 'abc')
 
-    def test_with_status(self):
+    def test__make_response_with_status(self):
         request = testing.DummyRequest()
         attrs = {'response_status':'406 You Lose'}
         request.__dict__.update(attrs)
-        response = self._callFUT(request, 'abc')
+        helper = self._makeOne('loo.foo')
+        response = helper._make_response('abc', request)
         self.assertEqual(response.status, '406 You Lose')
         self.assertEqual(response.body, 'abc')
 
-    def test_with_charset(self):
+    def test__make_response_with_charset(self):
         request = testing.DummyRequest()
         attrs = {'response_charset':'UTF-16'}
         request.__dict__.update(attrs)
-        response = self._callFUT(request, 'abc')
+        helper = self._makeOne('loo.foo')
+        response = helper._make_response('abc', request)
         self.assertEqual(response.charset, 'UTF-16')
 
-    def test_with_cache_for(self):
+    def test__make_response_with_cache_for(self):
         request = testing.DummyRequest()
         attrs = {'response_cache_for':100}
         request.__dict__.update(attrs)
-        response = self._callFUT(request, 'abc')
+        helper = self._makeOne('loo.foo')
+        response = helper._make_response('abc', request)
         self.assertEqual(response.cache_control.max_age, 100)
 
     def test_with_alternate_response_factory(self):
@@ -303,111 +382,22 @@ class Test__make_response(unittest.TestCase):
                 self.result = result
         self.config.registry.registerUtility(ResponseFactory, IResponseFactory)
         request = testing.DummyRequest()
-        response = self._callFUT(request, 'abc')
+        helper = self._makeOne('loo.foo')
+        response = helper._make_response('abc', request)
         self.assertEqual(response.__class__, ResponseFactory)
         self.assertEqual(response.result, 'abc')
 
-    def test_with_real_request(self):
+    def test__make_response_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')
+        helper = self._makeOne('loo.foo')
+        response = helper._make_response('abc', request)
         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()
@@ -415,15 +405,15 @@ class Test_render(unittest.TestCase):
     def tearDown(self):
         testing.tearDown()
 
-    def _callFUT(self, renderer_name, **kw):
+    def _callFUT(self, renderer_name, value, request=None, package=None):
         from repoze.bfg.renderers import render
-        return render(renderer_name, **kw)
+        return render(renderer_name, value, request=request, package=package)
 
     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)
+        result = self._callFUT('abc/def.pt', dict(a=1))
         self.assertEqual(result, 'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=None)
@@ -434,7 +424,7 @@ class Test_render(unittest.TestCase):
         renderer.string_response = 'abc'
         request = testing.DummyRequest()
         result = self._callFUT('abc/def.pt',
-                               a=1, request=request)
+                               dict(a=1), request=request)
         self.assertEqual(result, 'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=request)
@@ -446,15 +436,16 @@ class Test_render_to_response(unittest.TestCase):
     def tearDown(self):
         testing.tearDown()
 
-    def _callFUT(self, renderer_name, **kw):
+    def _callFUT(self, renderer_name, value, request=None, package=None):
         from repoze.bfg.renderers import render_to_response
-        return render_to_response(renderer_name, **kw)
+        return render_to_response(renderer_name, value, request=request,
+                                  package=package)
 
     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)
+        response = self._callFUT('abc/def.pt', dict(a=1))
         self.assertEqual(response.body, 'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=None)
@@ -465,7 +456,7 @@ class Test_render_to_response(unittest.TestCase):
         renderer.string_response = 'abc'
         request = testing.DummyRequest()
         response = self._callFUT('abc/def.pt',
-                               a=1, request=request)
+                                 dict(a=1), request=request)
         self.assertEqual(response.body, 'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=request)
diff --git a/repoze/bfg/tests/test_resource.py b/repoze/bfg/tests/test_resource.py
index 39f883ba1..191d72c8b 100644
--- a/repoze/bfg/tests/test_resource.py
+++ b/repoze/bfg/tests/test_resource.py
@@ -373,7 +373,15 @@ class Test_resolve_resource_spec(unittest.TestCase):
         package_name, filename = self._callFUT(path, pkg)
         self.assertEqual(package_name, None)
         self.assertEqual(filename, 'test_resource.py')
-        
+
+    def test_package_name_is_package_object(self):
+        import repoze.bfg.tests
+        pkg = repoze.bfg.tests
+        path = 'test_resource.py'
+        package_name, filename = self._callFUT(path, pkg)
+        self.assertEqual(package_name, 'repoze.bfg.tests')
+        self.assertEqual(filename, 'test_resource.py')
+
 
 class TestFileOverride(unittest.TestCase):
     def _getTargetClass(self):
diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py
index fc3bd7c9e..b24843e77 100644
--- a/repoze/bfg/tests/test_testing.py
+++ b/repoze/bfg/tests/test_testing.py
@@ -67,7 +67,7 @@ class Test_registerTemplateRenderer(TestBase):
         from repoze.bfg.testing import DummyTemplateRenderer
         self.failUnless(isinstance(renderer, DummyTemplateRenderer))
         from repoze.bfg.renderers import render_to_response
-        render_to_response('templates/foo', foo=1, bar=2)
+        render_to_response('templates/foo', dict(foo=1, bar=2))
         renderer.assert_(foo=1)
         renderer.assert_(bar=2)
 
@@ -77,7 +77,7 @@ class Test_registerTemplateRenderer(TestBase):
             self.assertEqual(kw, {'foo':1, 'bar':2})
         renderer = testing.registerTemplateRenderer('templates/foo', renderer)
         from repoze.bfg.renderers import render_to_response
-        render_to_response('templates/foo', foo=1, bar=2)
+        render_to_response('templates/foo', dict(foo=1, bar=2))
 
 class Test_registerEventListener(TestBase):
     def test_registerEventListener_single(self):