- A ZCML ``view`` directive (and the associated ``bfg_view``

  decorator) can now accept an "attr" value.  If an "attr" value is
  supplied, it is considered a method named of the view object to be
  called when the response is required.  This is typically only good
  for views that are classes or instances (not so useful for
  functions, as functions typically have no methods other than
  ``__call__``).

- A ZCML ``view`` directive (and the associated ``bfg_view``
  decorator) can now accept a "template" value.  If a "template" value
  is supplied, and the view callable returns a dictionary, the
  associated template is rendered with the dictionary as keyword
  arguments.

4 files changed, 409 insertions, 42 deletions

diff --git a/repoze/bfg/tests/test_chameleon_text.py b/repoze/bfg/tests/test_chameleon_text.py
index 74d348d14..139a77072 100644
--- a/repoze/bfg/tests/test_chameleon_text.py
+++ b/repoze/bfg/tests/test_chameleon_text.py
@@ -5,6 +5,13 @@ from repoze.bfg.testing import cleanUp
 class Base:
     def setUp(self):
         cleanUp()
+        import os
+        try:
+            # avoid spew from chameleon logger?
+            os.unlink(self._getTemplatePath('minimal.txt.py'))
+        except:
+            pass
+            
 
     def tearDown(self):
         cleanUp()
diff --git a/repoze/bfg/tests/test_templating.py b/repoze/bfg/tests/test_templating.py
index 6b317fb7d..c3894cce4 100644
--- a/repoze/bfg/tests/test_templating.py
+++ b/repoze/bfg/tests/test_templating.py
@@ -142,6 +142,37 @@ class TestRendererFromCache(unittest.TestCase):
         self.assertNotEqual(queryUtility(ITemplateRenderer, name=spec),
                             None)
 
+class TestRendererFromPath(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    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 test_with_nondefault(self):
+        from repoze.bfg.interfaces import ITemplateRendererFactory
+        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
+        testing.registerUtility(factory, ITemplateRendererFactory, name='.pt')
+        result = self._callFUT(fixture)
+        self.assertEqual(result, renderer)
+
 class DummyFactory:
     def __init__(self, renderer):
         self.renderer = renderer
diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index f496ebb36..5639e9799 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -620,7 +620,7 @@ class TestMultiView(unittest.TestCase):
         response = mv.__call_permissive__(context, request)
         self.assertEqual(response, expected_response)
 
-class TestMapView(unittest.TestCase):
+class Test_map_view(unittest.TestCase):
     def setUp(self):
         cleanUp()
 
@@ -636,7 +636,22 @@ class TestMapView(unittest.TestCase):
             return 'OK'
         result = self._callFUT(view)
         self.failUnless(result is view)
-        self.assertEqual(view(None, None), 'OK')
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_view_as_function_with_attr(self):
+        def view(context, request):
+            """ """
+        result = self._callFUT(view, attr='__name__')
+        self.failIf(result is view)
+        self.assertRaises(TypeError, result, None, None)
+
+    def test_view_as_function_with_attr_and_template(self):
+        def view(context, request):
+            """ """
+        result = self._callFUT(view, attr='__name__',
+                               template='fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertRaises(TypeError, result, None, None)
         
     def test_view_as_function_requestonly(self):
         def view(request):
@@ -648,6 +663,16 @@ class TestMapView(unittest.TestCase):
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
+    def test_view_as_function_requestonly_with_attr(self):
+        def view(request):
+            """ """
+        result = self._callFUT(view, attr='__name__')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertRaises(TypeError, result, None, None)
+
     def test_view_as_newstyle_class_context_and_request(self):
         class view(object):
             def __init__(self, context, request):
@@ -660,10 +685,38 @@ class TestMapView(unittest.TestCase):
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
+
+    def test_view_as_newstyle_class_context_and_request_with_attr(self):
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = self._callFUT(view, attr='index')
+        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), 'OK')
+
+    def test_view_as_newstyle_class_context_and_request_with_attr_and_template(
+        self):
+        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')
+        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')
         
     def test_view_as_newstyle_class_requestonly(self):
         class view(object):
-            def __init__(self, context, request):
+            def __init__(self, request):
                 pass
             def __call__(self):
                 return 'OK'
@@ -674,6 +727,33 @@ class TestMapView(unittest.TestCase):
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
+    def test_view_as_newstyle_class_requestonly_with_attr(self):
+        class view(object):
+            def __init__(self, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = self._callFUT(view, attr='index')
+        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), 'OK')
+
+    def test_view_as_newstyle_class_requestonly_with_attr_and_template(self):
+        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')
+        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')
+
     def test_view_as_oldstyle_class_context_and_request(self):
         class view:
             def __init__(self, context, request):
@@ -686,11 +766,39 @@ class TestMapView(unittest.TestCase):
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
-        
-    def test_view_as_oldstyle_class_requestonly(self):
+
+    def test_view_as_oldstyle_class_context_and_request_with_attr(self):
         class view:
             def __init__(self, context, request):
                 pass
+            def index(self):
+                return 'OK'
+        result = self._callFUT(view, attr='index')
+        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), 'OK')
+
+    def test_view_as_oldstyle_class_context_and_request_with_attr_and_template(
+        self):
+        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')
+        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')
+
+    def test_view_as_oldstyle_class_requestonly(self):
+        class view:
+            def __init__(self, request):
+                pass
             def __call__(self):
                 return 'OK'
         result = self._callFUT(view)
@@ -700,6 +808,33 @@ class TestMapView(unittest.TestCase):
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
+    def test_view_as_oldstyle_class_requestonly_with_attr(self):
+        class view:
+            def __init__(self, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = self._callFUT(view, attr='index')
+        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), 'OK')
+
+    def test_view_as_oldstyle_class_requestonly_with_attr_and_template(self):
+        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')
+        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')
+
     def test_view_as_instance_context_and_request(self):
         class View:
             def __call__(self, context, request):
@@ -709,6 +844,25 @@ class TestMapView(unittest.TestCase):
         self.failUnless(result is view)
         self.assertEqual(result(None, None), 'OK')
         
+    def test_view_as_instance_context_and_request_and_attr(self):
+        class View:
+            def index(self, context, request):
+                return 'OK'
+        view = View()
+        result = self._callFUT(view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_view_as_instance_context_and_request_attr_and_template(self):
+        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')
+        self.failIf(result is view)
+        self.assertEqual(result(None, None).body, 'Hello.\n')
+
     def test_view_as_instance_requestonly(self):
         class View:
             def __call__(self, request):
@@ -721,6 +875,41 @@ class TestMapView(unittest.TestCase):
         self.failUnless('instance' in result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
+    def test_view_as_instance_requestonly_with_attr(self):
+        class View:
+            def index(self, request):
+                return 'OK'
+        view = View()
+        result = self._callFUT(view, attr='index')
+        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), 'OK')
+
+    def test_view_as_instance_requestonly_with_attr_and_template(self):
+        class View:
+            def index(self, request):
+                return {'a':'1'}
+        view = View()
+        result = self._callFUT(view, attr='index',
+                               template='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')
+
+    def test_view_templateonly(self):
+        def view(context, request):
+            return {'a':'1'}
+        result = self._callFUT(view,
+                               template='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')
+
 class TestRequestOnly(unittest.TestCase):
     def _callFUT(self, arg):
         from repoze.bfg.view import requestonly
@@ -923,6 +1112,71 @@ class TestDecorateView(unittest.TestCase):
         self.failUnless(view1.__predicated__.im_func is
                         view2.__predicated__.im_func)
 
+class Test_templated_response(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        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)
+
+    def test_is_response(self):
+        response = DummyResponse()
+        result = self._callFUT(
+            'repoze.bfg.tests:fixtures/minimal.txt', response)
+        self.assertEqual(result, response)
+
+    def test_is_not_valid_dict(self):
+        response = None
+        result = self._callFUT(
+            'repoze.bfg.tests:fixtures/minimal.txt', response)
+        self.assertEqual(result, response)
+        
+    def test_valid_dict(self):
+        response = {'a':'1'}
+        result = self._callFUT(
+            'repoze.bfg.tests:fixtures/minimal.txt', response)
+        self.assertEqual(result.body, 'Hello.\n')
+
+    def test_with_content_type(self):
+        response = {'a':'1', 'content_type_':'text/nonsense'}
+        result = self._callFUT(
+            'repoze.bfg.tests:fixtures/minimal.txt', response)
+        self.assertEqual(result.content_type, 'text/nonsense')
+
+    def test_with_headerlist(self):
+        response = {'a':'1', 'headerlist_':[('a', '1'), ('b', '2')]}
+        result = self._callFUT(
+            'repoze.bfg.tests:fixtures/minimal.txt', response)
+        self.assertEqual(result.headerlist,
+                         [('Content-Type', 'text/html; charset=UTF-8'),
+                          ('Content-Length', '7'),
+                          ('a', '1'),
+                          ('b', '2')])
+
+    def test_with_status(self):
+        response = {'a':'1', 'status_':'406 You Lose'}
+        result = self._callFUT(
+            'repoze.bfg.tests:fixtures/minimal.txt', response)
+        self.assertEqual(result.status, '406 You Lose')
+
+    def test_with_charset(self):
+        response = {'a':'1', 'charset_':'UTF-16'}
+        result = self._callFUT(
+            'repoze.bfg.tests:fixtures/minimal.txt', response)
+        self.assertEqual(result.charset, 'UTF-16')
+
+    def test_with_cache_for(self):
+        response = {'a':'1', 'cache_for_':100}
+        result = self._callFUT(
+            'repoze.bfg.tests:fixtures/minimal.txt', response)
+        self.assertEqual(result.cache_control.max_age, 100)
+
 class DummyContext:
     pass
 
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 9e8c70cbd..e54bd108f 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -1,3 +1,7 @@
+import logging
+
+logging.basicConfig()
+
 import unittest
 
 from repoze.bfg.testing import cleanUp
@@ -35,7 +39,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -66,7 +71,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -102,7 +108,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -133,7 +140,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -172,7 +180,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -210,7 +219,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -249,7 +259,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -287,7 +298,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -303,6 +315,45 @@ class TestViewDirective(unittest.TestCase):
         perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
         self.assertEqual(perm, None)
 
+    def test_with_reltemplate(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
+
+        import repoze.bfg.tests
+
+        context = DummyContext(repoze.bfg.tests)
+        class IFoo(Interface):
+            pass
+        class view(object):
+            def __init__(self, context, request):
+                self.request = request
+                self.context = context
+
+            def __call__(self):
+                return {'a':'1'}
+
+        import os
+        fixture = 'fixtures/minimal.txt'
+        self._callFUT(context, 'repoze.view', IFoo, view=view, template=fixture)
+        actions = context.actions
+        self.assertEqual(len(actions), 1)
+
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
+        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')
 
     def test_request_type_asinterface(self):
         from zope.component import getSiteManager
@@ -322,7 +373,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IDummy, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IDummy, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -352,7 +404,7 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', Dummy, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', Dummy, IView, None, None, None, None, None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -378,7 +430,8 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'GET', None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'GET', None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -407,7 +460,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
 
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(actions[0]['discriminator'], discrim)
         register = actions[0]['callable']
         register()
@@ -441,7 +495,7 @@ class TestViewDirective(unittest.TestCase):
         factory = sm.getUtility(IRouteRequest, 'foo')
         request_type = implementedBy(factory)
         discrim = ('view', IFoo, '', request_type, IView, None, None, None,
-                   'foo')
+                   'foo', None)
         self.assertEqual(action['discriminator'], discrim)
         the_view = sm.adapters.lookup((IFoo, request_type), IView, name='')
         request = factory({})
@@ -463,7 +517,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'POST', None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'POST', None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -489,7 +544,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'POST', None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'POST', None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -514,7 +570,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -540,7 +597,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -565,7 +623,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -591,7 +650,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -618,7 +678,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, IFoo, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, IFoo, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -645,7 +706,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, IFoo, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, IFoo, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -673,7 +735,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -715,7 +778,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -741,7 +805,8 @@ class TestViewDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        discrim = ('view', Foo, '', IRequest, IView, None, None, None, None)
+        discrim = ('view', Foo, '', IRequest, IView, None, None, None, None,
+                   None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
         register()
@@ -1110,7 +1175,7 @@ class TestDeriveView(unittest.TestCase):
     def test_view_with_debug_authorization_no_authpol(self):
         def view(context, request):
             return 'OK'
-        self._registerSettings(debug_authorization=True)
+        self._registerSettings(debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
         result = self._callFUT(view, permission='view')
         self.assertEqual(view.__module__, result.__module__)
@@ -1130,7 +1195,7 @@ class TestDeriveView(unittest.TestCase):
     def test_view_with_debug_authorization_no_permission(self):
         def view(context, request):
             return 'OK'
-        self._registerSettings(debug_authorization=True)
+        self._registerSettings(debug_authorization=True, reload_templates=True)
         self._registerSecurityPolicy(True)
         logger = self._registerLogger()
         result = self._callFUT(view)
@@ -1151,7 +1216,7 @@ class TestDeriveView(unittest.TestCase):
     def test_view_with_debug_authorization_permission_authpol_permitted(self):
         def view(context, request):
             return 'OK'
-        self._registerSettings(debug_authorization=True)
+        self._registerSettings(debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
         self._registerSecurityPolicy(True)
         result = self._callFUT(view, permission='view')
@@ -1172,7 +1237,7 @@ class TestDeriveView(unittest.TestCase):
         from repoze.bfg.security import Unauthorized
         def view(context, request):
             """ """
-        self._registerSettings(debug_authorization=True)
+        self._registerSettings(debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
         self._registerSecurityPolicy(False)
         result = self._callFUT(view, permission='view')
@@ -1192,7 +1257,7 @@ class TestDeriveView(unittest.TestCase):
     def test_view_with_debug_authorization_permission_authpol_denied2(self):
         def view(context, request):
             """ """
-        self._registerSettings(debug_authorization=True)
+        self._registerSettings(debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
         self._registerSecurityPolicy(False)
         result = self._callFUT(view, permission='view')
@@ -1330,7 +1395,7 @@ class TestRouteDirective(unittest.TestCase):
         request_factory = sm.getUtility(IRouteRequest, 'name')
         request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(len(view_discriminator), 10)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], None)
         self.assertEqual(view_discriminator[2],'')
@@ -1340,6 +1405,7 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(view_discriminator[6], None)
         self.assertEqual(view_discriminator[7], None)
         self.assertEqual(view_discriminator[8], 'name')
+        self.assertEqual(view_discriminator[9], None)
         register = view_action['callable']
         register()
         sm = getSiteManager()
@@ -1378,7 +1444,7 @@ class TestRouteDirective(unittest.TestCase):
         request_factory = sm.getUtility(IRouteRequest, 'name')
         request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(len(view_discriminator), 10)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], IDummy)
         self.assertEqual(view_discriminator[2],'')
@@ -1388,6 +1454,7 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(view_discriminator[6], None)
         self.assertEqual(view_discriminator[7], None)
         self.assertEqual(view_discriminator[8], 'name')
+        self.assertEqual(view_discriminator[9], None)
         wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
         request = DummyRequest()
         self.assertEqual(wrapped(None, request), '123')
@@ -1441,7 +1508,7 @@ class TestRouteDirective(unittest.TestCase):
         request_factory = sm.getUtility(IRouteRequest, 'name')
         request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(len(view_discriminator), 10)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], None)
         self.assertEqual(view_discriminator[2],'')
@@ -1451,6 +1518,7 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(view_discriminator[6], None)
         self.assertEqual(view_discriminator[7], 'GET')
         self.assertEqual(view_discriminator[8], 'name')
+        self.assertEqual(view_discriminator[9], None)
         wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
         self.failUnless(wrapped)
 
@@ -1485,7 +1553,7 @@ class TestRouteDirective(unittest.TestCase):
         request_factory = sm.getUtility(IRouteRequest, 'name')
         request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(len(view_discriminator), 10)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], None)
         self.assertEqual(view_discriminator[2],'')
@@ -1495,6 +1563,7 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(view_discriminator[6], None)
         self.assertEqual(view_discriminator[7], 'GET')
         self.assertEqual(view_discriminator[8], 'name')
+        self.assertEqual(view_discriminator[9], None)
         wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
         self.failUnless(wrapped)
 
@@ -1530,7 +1599,7 @@ class TestRouteDirective(unittest.TestCase):
         request_factory = sm.getUtility(IRouteRequest, 'name')
         request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(len(view_discriminator), 10)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], None)
         self.assertEqual(view_discriminator[2],'')
@@ -1540,6 +1609,7 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(view_discriminator[6], None)
         self.assertEqual(view_discriminator[7], 'GET')
         self.assertEqual(view_discriminator[8], 'name')
+        self.assertEqual(view_discriminator[9], None)
         wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
         self.failUnless(wrapped)
 
@@ -1574,7 +1644,7 @@ class TestRouteDirective(unittest.TestCase):
         request_factory = sm.getUtility(IRouteRequest, 'name')
         request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(len(view_discriminator), 10)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], None)
         self.assertEqual(view_discriminator[2],'')
@@ -1584,6 +1654,7 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(view_discriminator[6], None)
         self.assertEqual(view_discriminator[7], 'GET')
         self.assertEqual(view_discriminator[8], 'name')
+        self.assertEqual(view_discriminator[9], None)
         wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
         self.failUnless(wrapped)
 
@@ -1618,7 +1689,7 @@ class TestRouteDirective(unittest.TestCase):
         request_factory = sm.getUtility(IRouteRequest, 'name')
         request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(len(view_discriminator), 10)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], None)
         self.assertEqual(view_discriminator[2],'')
@@ -1628,6 +1699,7 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(view_discriminator[6], None)
         self.assertEqual(view_discriminator[7], None)
         self.assertEqual(view_discriminator[8], 'name')
+        self.assertEqual(view_discriminator[9], None)
         wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
         self.failUnless(wrapped)
 
@@ -1662,7 +1734,7 @@ class TestRouteDirective(unittest.TestCase):
         request_factory = sm.getUtility(IRouteRequest, 'name')
         request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(len(view_discriminator), 10)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], None)
         self.assertEqual(view_discriminator[2],'')
@@ -1672,6 +1744,7 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(view_discriminator[6], None)
         self.assertEqual(view_discriminator[7], None)
         self.assertEqual(view_discriminator[8], 'name')
+        self.assertEqual(view_discriminator[9], None)
         wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
         self.failUnless(wrapped)
 
@@ -2010,6 +2083,8 @@ class TestBFGViewFunctionGrokker(unittest.TestCase):
         obj.__request_method__ = None
         obj.__request_param__ = None
         obj.__containment__ = None
+        obj.__attr__ = None
+        obj.__template__ = None
         context = DummyContext()
         result = grokker.grok('name', obj, context=context)
         self.assertEqual(result, True)