Checkpoint. Not 100% test coverage.

6 files changed, 158 insertions, 76 deletions

diff --git a/repoze/bfg/tests/test_chameleon_text.py b/repoze/bfg/tests/test_chameleon_text.py
index 139a77072..ddb6f717a 100644
--- a/repoze/bfg/tests/test_chameleon_text.py
+++ b/repoze/bfg/tests/test_chameleon_text.py
@@ -51,7 +51,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase):
         self._zcmlConfigure()
         minimal = self._getTemplatePath('minimal.txt')
         instance = self._makeOne(minimal)
-        result = instance()
+        result = instance({})
         self.failUnless(isinstance(result, str))
         self.assertEqual(result, 'Hello.\n')
 
@@ -59,7 +59,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase):
         self._zcmlConfigure()
         nonminimal = self._getTemplatePath('nonminimal.txt')
         instance = self._makeOne(nonminimal)
-        result = instance(name='Chris')
+        result = instance({'name':'Chris'})
         self.failUnless(isinstance(result, str))
         self.assertEqual(result, 'Hello, Chris!\n')
 
diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py
index 4a1cac166..f6d7c0da5 100644
--- a/repoze/bfg/tests/test_chameleon_zpt.py
+++ b/repoze/bfg/tests/test_chameleon_zpt.py
@@ -44,7 +44,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase):
         self._zcmlConfigure()
         minimal = self._getTemplatePath('minimal.pt')
         instance = self._makeOne(minimal)
-        result = instance()
+        result = instance({})
         self.failUnless(isinstance(result, unicode))
         self.assertEqual(result,
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
diff --git a/repoze/bfg/tests/test_templating.py b/repoze/bfg/tests/test_renderers.py
index c3894cce4..aa159cc18 100644
--- a/repoze/bfg/tests/test_templating.py
+++ b/repoze/bfg/tests/test_renderers.py
@@ -3,16 +3,16 @@ import unittest
 from repoze.bfg.testing import cleanUp
 from repoze.bfg import testing
 
-class TestRendererFromCache(unittest.TestCase):
+class TestTemplateRendererFactory(unittest.TestCase):
     def setUp(self):
         cleanUp()
 
     def tearDown(self):
         cleanUp()
         
-    def _callFUT(self, path, factory, level=3, **kw):
-        from repoze.bfg.templating import renderer_from_cache
-        return renderer_from_cache(path, factory, level, **kw)
+    def _callFUT(self, path, factory, level=3):
+        from repoze.bfg.renderers import template_renderer_factory
+        return template_renderer_factory(path, factory, level)
 
     def test_abspath_notfound(self):
         from repoze.bfg.interfaces import ITemplateRenderer
@@ -87,10 +87,10 @@ class TestRendererFromCache(unittest.TestCase):
         import os
         from repoze.bfg.tests import test_templating
         module_name = test_templating.__name__
-        relpath = 'test_templating.py'
+        relpath = 'test_renderers.py'
         renderer = {}
         factory = DummyFactory(renderer)
-        result = self._callFUT('test_templating.py', factory)
+        result = self._callFUT('test_renderers.py', factory)
         self.failUnless(result is renderer)
         path = os.path.abspath(__file__)
         if path.endswith('pyc'): # pragma: no cover
@@ -102,7 +102,7 @@ class TestRendererFromCache(unittest.TestCase):
         import os
         from repoze.bfg import tests
         module_name = tests.__name__
-        relpath = 'test_templating.py'
+        relpath = 'test_renderers.py'
         renderer = {}
         factory = DummyFactory(renderer)
         spec = '%s:%s' % (module_name, relpath)
@@ -122,9 +122,9 @@ class TestRendererFromCache(unittest.TestCase):
         testing.registerUtility(settings, ISettings)
         renderer = {}
         factory = DummyFactory(renderer)
-        result = self._callFUT('test_templating.py', factory)
+        result = self._callFUT('test_renderers.py', factory)
         self.failUnless(result is renderer)
-        spec = '%s:%s' % ('repoze.bfg.tests', 'test_templating.py')
+        spec = '%s:%s' % ('repoze.bfg.tests', 'test_renderers.py')
         self.assertEqual(queryUtility(ITemplateRenderer, name=spec),
                          None)
 
@@ -136,9 +136,9 @@ class TestRendererFromCache(unittest.TestCase):
         testing.registerUtility(settings, ISettings)
         renderer = {}
         factory = DummyFactory(renderer)
-        result = self._callFUT('test_templating.py', factory)
+        result = self._callFUT('test_renderers.py', factory)
         self.failUnless(result is renderer)
-        spec = '%s:%s' % ('repoze.bfg.tests', 'test_templating.py')
+        spec = '%s:%s' % ('repoze.bfg.tests', 'test_renderers.py')
         self.assertNotEqual(queryUtility(ITemplateRenderer, name=spec),
                             None)
 
@@ -149,19 +149,11 @@ class TestRendererFromPath(unittest.TestCase):
     def tearDown(self):
         cleanUp()
         
-    def _callFUT(self, path, level=4, **kw):
-        from repoze.bfg.templating import renderer_from_path
-        return renderer_from_path(path, level, **kw)
-
-    def test_with_default(self):
-        from repoze.bfg.templating import TextTemplateRenderer
-        import os
-        here = os.path.dirname(os.path.abspath(__file__))
-        fixture = os.path.join(here, 'fixtures/minimal.txt')
-        result = self._callFUT(fixture)
-        self.assertEqual(result.__class__, TextTemplateRenderer)
+    def _callFUT(self, path, level=4):
+        from repoze.bfg.renderers import renderer_from_name
+        return renderer_from_name(path, level)
 
-    def test_with_nondefault(self):
+    def test_it(self):
         from repoze.bfg.interfaces import ITemplateRendererFactory
         import os
         here = os.path.dirname(os.path.abspath(__file__))
diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py
index e81a90219..9ebd8468a 100644
--- a/repoze/bfg/tests/test_testing.py
+++ b/repoze/bfg/tests/test_testing.py
@@ -65,7 +65,7 @@ class TestTestingFunctions(unittest.TestCase):
 
     def test_registerDummyRenderer_explicitrenderer(self):
         from repoze.bfg import testing
-        def renderer(**kw):
+        def renderer(kw):
             raise ValueError
         renderer = testing.registerDummyRenderer('templates/foo', renderer)
         from repoze.bfg.chameleon_zpt import render_template_to_response
@@ -460,20 +460,20 @@ class TestDummyTemplateRenderer(unittest.TestCase):
 
     def test_getattr(self):
         renderer = self._makeOne()
-        renderer(a=1)
+        renderer({'a':1})
         self.assertEqual(renderer.a, 1)
         self.assertRaises(AttributeError, renderer.__getattr__, 'b')
 
     def test_assert_(self):
         renderer = self._makeOne()
-        renderer(a=1, b=2)
+        renderer({'a':1, 'b':2})
         self.assertRaises(AssertionError, renderer.assert_, c=1)
         self.assertRaises(AssertionError, renderer.assert_, b=3)
         self.failUnless(renderer.assert_(a=1, b=2))
         
     def test_nondefault_string_response(self):
         renderer = self._makeOne('abc')
-        result = renderer(a=1, b=2)
+        result = renderer({'a':1, 'b':2})
         self.assertEqual(result, 'abc')
 
 class CleanUpTests(object):
diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index 5639e9799..3106359a3 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -631,6 +631,25 @@ class Test_map_view(unittest.TestCase):
         from repoze.bfg.view import map_view
         return map_view(view, *arg, **kw)
 
+    def _registerRenderer(self):
+        from repoze.bfg.interfaces import IRendererFactory
+        from repoze.bfg.interfaces import ITemplateRenderer
+        from zope.interface import implements
+        from zope.component import getSiteManager
+        class Renderer:
+            implements(ITemplateRenderer)
+            def __call__(self, *arg):
+                return 'Hello!'
+
+        class RendererFactory:
+            def __call__(self, path):
+                self.path = path
+                return Renderer()
+
+        factory = RendererFactory()
+        sm = getSiteManager()
+        sm.registerUtility(factory, IRendererFactory, name='.txt')
+
     def test_view_as_function_context_and_request(self):
         def view(context, request):
             return 'OK'
@@ -646,10 +665,11 @@ class Test_map_view(unittest.TestCase):
         self.assertRaises(TypeError, result, None, None)
 
     def test_view_as_function_with_attr_and_template(self):
+        self._registerRenderer()
         def view(context, request):
             """ """
         result = self._callFUT(view, attr='__name__',
-                               template='fixtures/minimal.txt')
+                               renderer='fixtures/minimal.txt')
         self.failIf(result is view)
         self.assertRaises(TypeError, result, None, None)
         
@@ -701,18 +721,20 @@ class Test_map_view(unittest.TestCase):
 
     def test_view_as_newstyle_class_context_and_request_with_attr_and_template(
         self):
+        self._registerRenderer()
         class view(object):
             def __init__(self, context, request):
                 pass
             def index(self):
                 return {'a':'1'}
         result = self._callFUT(view, attr='index',
-                               template='repoze.bfg.tests:fixtures/minimal.txt')
+                               renderer='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None).body, 'Hello.\n')
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
         
     def test_view_as_newstyle_class_requestonly(self):
         class view(object):
@@ -741,18 +763,20 @@ class Test_map_view(unittest.TestCase):
         self.assertEqual(result(None, None), 'OK')
 
     def test_view_as_newstyle_class_requestonly_with_attr_and_template(self):
+        self._registerRenderer()
         class view(object):
             def __init__(self, request):
                 pass
             def index(self):
                 return {'a':'1'}
         result = self._callFUT(view, attr='index',
-                               template='repoze.bfg.tests:fixtures/minimal.txt')
+                               renderer='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None).body, 'Hello.\n')
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
 
     def test_view_as_oldstyle_class_context_and_request(self):
         class view:
@@ -782,18 +806,20 @@ class Test_map_view(unittest.TestCase):
 
     def test_view_as_oldstyle_class_context_and_request_with_attr_and_template(
         self):
+        self._registerRenderer()
         class view:
             def __init__(self, context, request):
                 pass
             def index(self):
                 return {'a':'1'}
         result = self._callFUT(view, attr='index',
-                               template='repoze.bfg.tests:fixtures/minimal.txt')
+                               renderer='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None).body, 'Hello.\n')
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
 
     def test_view_as_oldstyle_class_requestonly(self):
         class view:
@@ -822,18 +848,20 @@ class Test_map_view(unittest.TestCase):
         self.assertEqual(result(None, None), 'OK')
 
     def test_view_as_oldstyle_class_requestonly_with_attr_and_template(self):
+        self._registerRenderer()
         class view:
             def __init__(self, request):
                 pass
             def index(self):
                 return {'a':'1'}
         result = self._callFUT(view, attr='index',
-                               template='repoze.bfg.tests:fixtures/minimal.txt')
+                               renderer='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None).body, 'Hello.\n')
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
 
     def test_view_as_instance_context_and_request(self):
         class View:
@@ -854,14 +882,16 @@ class Test_map_view(unittest.TestCase):
         self.assertEqual(result(None, None), 'OK')
 
     def test_view_as_instance_context_and_request_attr_and_template(self):
+        self._registerRenderer()
         class View:
             def index(self, context, request):
                 return {'a':'1'}
         view = View()
         result = self._callFUT(view, attr='index',
-                               template='repoze.bfg.tests:fixtures/minimal.txt')
+                               renderer='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
-        self.assertEqual(result(None, None).body, 'Hello.\n')
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
 
     def test_view_as_instance_requestonly(self):
         class View:
@@ -888,27 +918,31 @@ class Test_map_view(unittest.TestCase):
         self.assertEqual(result(None, None), 'OK')
 
     def test_view_as_instance_requestonly_with_attr_and_template(self):
+        self._registerRenderer()
         class View:
             def index(self, request):
                 return {'a':'1'}
         view = View()
         result = self._callFUT(view, attr='index',
-                               template='repoze.bfg.tests:fixtures/minimal.txt')
+                               renderer='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.failUnless('instance' in result.__name__)
-        self.assertEqual(result(None, None).body, 'Hello.\n')
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
 
     def test_view_templateonly(self):
+        self._registerRenderer()
         def view(context, request):
             return {'a':'1'}
         result = self._callFUT(view,
-                               template='repoze.bfg.tests:fixtures/minimal.txt')
+                               renderer='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(result(None, None).body, 'Hello.\n')
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
 
 class TestRequestOnly(unittest.TestCase):
     def _callFUT(self, arg):
@@ -1112,7 +1146,7 @@ class TestDecorateView(unittest.TestCase):
         self.failUnless(view1.__predicated__.im_func is
                         view2.__predicated__.im_func)
 
-class Test_templated_response(unittest.TestCase):
+class Test_rendered_response(unittest.TestCase):
     def setUp(self):
         cleanUp()
 
@@ -1120,61 +1154,105 @@ class Test_templated_response(unittest.TestCase):
         cleanUp()
 
     def _callFUT(self, template_name, response, view=None,
-                 context=None, request=None, auto_reload=False):
-        from repoze.bfg.view import templated_response
-        return templated_response(template_name, response, view, context,
-                                  request, auto_reload)
+                 context=None, request=None):
+        from repoze.bfg.view import rendered_response
+        if request is None:
+            request = DummyRequest()
+        return rendered_response(template_name, response, view, context,
+                                 request)
+
+    def _registerRenderer(self):
+        from repoze.bfg.interfaces import IRendererFactory
+        from repoze.bfg.interfaces import ITemplateRenderer
+        from zope.interface import implements
+        from zope.component import getSiteManager
+        class Renderer:
+            implements(ITemplateRenderer)
+            def __call__(self, *arg):
+                return 'Hello!'
+
+        class RendererFactory:
+            def __call__(self, path):
+                self.path = path
+                return Renderer()
+
+        factory = RendererFactory()
+        sm = getSiteManager()
+        sm.registerUtility(factory, IRendererFactory, name='.txt')
 
     def test_is_response(self):
+        self._registerRenderer()
         response = DummyResponse()
         result = self._callFUT(
             'repoze.bfg.tests:fixtures/minimal.txt', response)
         self.assertEqual(result, response)
 
     def test_is_not_valid_dict(self):
+        self._registerRenderer()
         response = None
         result = self._callFUT(
             'repoze.bfg.tests:fixtures/minimal.txt', response)
         self.assertEqual(result, response)
         
     def test_valid_dict(self):
+        self._registerRenderer()
         response = {'a':'1'}
         result = self._callFUT(
             'repoze.bfg.tests:fixtures/minimal.txt', response)
-        self.assertEqual(result.body, 'Hello.\n')
+        self.assertEqual(result.body, 'Hello!')
 
     def test_with_content_type(self):
-        response = {'a':'1', 'content_type_':'text/nonsense'}
+        self._registerRenderer()
+        response = {'a':'1'}
+        request = DummyRequest()
+        attrs = {'response_content_type':'text/nonsense'}
+        request.environ['webob.adhoc_attrs'] = attrs
         result = self._callFUT(
-            'repoze.bfg.tests:fixtures/minimal.txt', response)
+            'repoze.bfg.tests:fixtures/minimal.txt', response, request=request)
         self.assertEqual(result.content_type, 'text/nonsense')
 
     def test_with_headerlist(self):
-        response = {'a':'1', 'headerlist_':[('a', '1'), ('b', '2')]}
+        self._registerRenderer()
+        response = {'a':'1'}
+        request = DummyRequest()
+        attrs = {'response_headerlist':[('a', '1'), ('b', '2')]}
+        request.environ['webob.adhoc_attrs'] = attrs
         result = self._callFUT(
-            'repoze.bfg.tests:fixtures/minimal.txt', response)
+            'repoze.bfg.tests:fixtures/minimal.txt', response, request=request)
         self.assertEqual(result.headerlist,
                          [('Content-Type', 'text/html; charset=UTF-8'),
-                          ('Content-Length', '7'),
+                          ('Content-Length', '6'),
                           ('a', '1'),
                           ('b', '2')])
 
     def test_with_status(self):
-        response = {'a':'1', 'status_':'406 You Lose'}
+        self._registerRenderer()
+        response = {'a':'1'}
+        request = DummyRequest()
+        attrs = {'response_status':'406 You Lose'}
+        request.environ['webob.adhoc_attrs'] = attrs
         result = self._callFUT(
-            'repoze.bfg.tests:fixtures/minimal.txt', response)
+            'repoze.bfg.tests:fixtures/minimal.txt', response, request=request)
         self.assertEqual(result.status, '406 You Lose')
 
     def test_with_charset(self):
-        response = {'a':'1', 'charset_':'UTF-16'}
+        self._registerRenderer()
+        response = {'a':'1'}
+        request = DummyRequest()
+        attrs = {'response_charset':'UTF-16'}
+        request.environ['webob.adhoc_attrs'] = attrs
         result = self._callFUT(
-            'repoze.bfg.tests:fixtures/minimal.txt', response)
+            'repoze.bfg.tests:fixtures/minimal.txt', response, request=request)
         self.assertEqual(result.charset, 'UTF-16')
 
     def test_with_cache_for(self):
-        response = {'a':'1', 'cache_for_':100}
+        self._registerRenderer()
+        response = {'a':'1'}
+        request = DummyRequest()
+        attrs = {'response_cache_for':100}
+        request.environ['webob.adhoc_attrs'] = attrs
         result = self._callFUT(
-            'repoze.bfg.tests:fixtures/minimal.txt', response)
+            'repoze.bfg.tests:fixtures/minimal.txt', response, request=request)
         self.assertEqual(result.cache_control.max_age, 100)
 
 class DummyContext:
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 208e8e754..21d55504d 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -320,8 +320,7 @@ class TestViewDirective(unittest.TestCase):
         from zope.component import getSiteManager
         from repoze.bfg.interfaces import IRequest
         from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-
+        from repoze.bfg.interfaces import IRendererFactory
         import repoze.bfg.tests
 
         context = DummyContext(repoze.bfg.tests)
@@ -335,9 +334,17 @@ class TestViewDirective(unittest.TestCase):
             def __call__(self):
                 return {'a':'1'}
 
-        import os
+        class Renderer:
+            def __call__(self, path):
+                self.path = path
+                return lambda *arg: 'Hello!'
+
+        renderer = Renderer()
+        sm = getSiteManager()
+        sm.registerUtility(renderer, IRendererFactory, name='.txt')
+
         fixture = 'fixtures/minimal.txt'
-        self._callFUT(context, 'repoze.view', IFoo, view=view, template=fixture)
+        self._callFUT(context, 'repoze.view', IFoo, view=view, renderer=fixture)
         actions = context.actions
         self.assertEqual(len(actions), 1)
 
@@ -347,29 +354,33 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
-        sm = getSiteManager()
         wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
         self.assertEqual(wrapper.__module__, view.__module__)
         self.assertEqual(wrapper.__name__, view.__name__)
         self.assertEqual(wrapper.__doc__, view.__doc__)
-        result = wrapper(None, None)
-        self.assertEqual(result.body, 'Hello.\n')
+        request = DummyRequest()
+        result = wrapper(None, request)
+        self.assertEqual(result.body, 'Hello!')
+        self.assertEqual(renderer.path, 'repoze.bfg.tests:fixtures/minimal.txt')
 
     def test_with_template_no_view_callable(self):
         from zope.interface import Interface
         from zope.component import getSiteManager
         from repoze.bfg.interfaces import IRequest
         from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
+        from repoze.bfg.interfaces import IRendererFactory
 
         import repoze.bfg.tests
 
         context = DummyContext(repoze.bfg.tests)
         class IFoo(Interface):
             pass
-        import os
-        fixture = 'fixtures/minimal.txt'
-        self._callFUT(context, 'repoze.view', IFoo, template=fixture)
+        sm = getSiteManager()
+        def renderer_factory(path):
+            return lambda *arg: 'Hello!'
+        sm.registerUtility(renderer_factory, IRendererFactory, name='.txt')
+
+        self._callFUT(context, 'repoze.view', IFoo, renderer='foo.txt')
         actions = context.actions
         self.assertEqual(len(actions), 1)
 
@@ -379,10 +390,11 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
-        sm = getSiteManager()
         wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        result = wrapper(None, None)
-        self.assertEqual(result.body, 'Hello.\n')
+        request = DummyRequest()
+        request.environ = {}
+        result = wrapper(None, request)
+        self.assertEqual(result.body, 'Hello!')
 
     def test_request_type_asinterface(self):
         from zope.component import getSiteManager