- The ``repoze.bfg.testing.registerDummyRenderer`` API has been

  deprecated in favor of
  ``repoze.bfg.testing.registerTemplateRenderer``.  A deprecation
  warning is *not* issued at import time for the former name; it will
  exist "forever".

- The ``repoze.bfg.templating.renderer_from_cache`` function has been
  moved to ``repoze.bfg.renderer.template_renderer_factory``.  This
  was never an API, but code in the wild was spotted that used it.  A
  deprecation warning is issued at import time for the former.

- Better error message when a wrapper view returns None.

4 files changed, 37 insertions, 16 deletions

diff --git a/repoze/bfg/testing.py b/repoze/bfg/testing.py
index bdf60de40..7b694b242 100644
--- a/repoze/bfg/testing.py
+++ b/repoze/bfg/testing.py
@@ -69,11 +69,11 @@ def registerEventListener(event_iface=Interface):
     registerSubscriber(subscriber, event_iface)
     return L
 
-def registerDummyRenderer(path, renderer=None):
-    """ Register a 'renderer' at ``path`` (usually a relative filename
-    ala ``templates/foo.pt``) and return the renderer object.  If the
-    ``renderer`` argument is None, a 'dummy' renderer will be used.
-    This function is useful when testing code that calls the
+def registerTemplateRenderer(path, renderer=None):
+    """ Register a 'template renderer' at ``path`` (usually a relative
+    filename ala ``templates/foo.pt``) and return the renderer object.
+    If the ``renderer`` argument is None, a 'dummy' renderer will be
+    used.  This function is useful when testing code that calls the
     ``render_template_to_response`` or any other ``render_template*``
     API of any of the built-in templating systems."""
     from repoze.bfg.interfaces import ITemplateRenderer
@@ -81,6 +81,10 @@ def registerDummyRenderer(path, renderer=None):
         renderer = DummyTemplateRenderer()
     return registerUtility(renderer, ITemplateRenderer, path)
 
+# registerDummyRenderer is a deprecated alias that should never be removed
+# (far too much usage in the wild)
+registerDummyRenderer = registerTemplateRenderer
+
 def registerView(name, result='', view=None, for_=(Interface, Interface),
                  permission=None):
     """ Registers ``repoze.bfg`` view function under the name
@@ -251,7 +255,7 @@ class DummySecurityPolicy:
 class DummyTemplateRenderer:
     """
     An instance of this class is returned from
-    ``registerDummyRenderer``.  It has a helper function (``assert_``)
+    ``registerTemplateRenderer``.  It has a helper function (``assert_``)
     that makes it possible to make an assertion which compares data
     passed to the renderer by the view function against expected
     key/value pairs. 
diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py
index f479106ce..6c6b55337 100644
--- a/repoze/bfg/tests/test_testing.py
+++ b/repoze/bfg/tests/test_testing.py
@@ -54,20 +54,20 @@ class TestTestingFunctions(unittest.TestCase):
         from repoze.bfg.traversal import find_model
         self.assertEqual(find_model(None, '/ob1'), ob1)
 
-    def test_registerDummyRenderer(self):
+    def test_registerTemplateRenderer(self):
         from repoze.bfg import testing
-        renderer = testing.registerDummyRenderer('templates/foo')
+        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
         response = render_template_to_response('templates/foo', foo=1, bar=2)
         self.assertEqual(dict(foo=1, bar=2), renderer._received)
 
-    def test_registerDummyRenderer_explicitrenderer(self):
+    def test_registerTemplateRenderer_explicitrenderer(self):
         from repoze.bfg import testing
         def renderer(kw):
             raise ValueError
-        renderer = testing.registerDummyRenderer('templates/foo', renderer)
+        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)
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 21d55504d..7af9ab193 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -1376,7 +1376,8 @@ class TestDeriveView(unittest.TestCase):
             return Response('outer ' + request.wrapped_body)
         sm = getSiteManager()
         sm.registerAdapter(outer_view, (None, None), IView, 'owrap')
-        result = self._callFUT(inner_view, wrapper_viewname='owrap')
+        result = self._callFUT(inner_view, viewname='inner',
+                               wrapper_viewname='owrap')
         self.failIf(result is inner_view)
         self.assertEqual(inner_view.__module__, result.__module__)
         self.assertEqual(inner_view.__doc__, result.__doc__)
@@ -1384,6 +1385,16 @@ class TestDeriveView(unittest.TestCase):
         response = result(None, request)
         self.assertEqual(response.body, 'outer OK')
 
+    def test_view_with_wrapper_viewname_notfound(self):
+        from webob import Response
+        inner_response = Response('OK')
+        def inner_view(context, request):
+            return inner_response
+        request = DummyRequest()
+        wrapped = self._callFUT(
+            inner_view, viewname='inner', wrapper_viewname='owrap')
+        result = self.assertRaises(ValueError, wrapped, None, request)
+
 class TestConnectRouteFunction(unittest.TestCase):
     def setUp(self):
         cleanUp()
diff --git a/repoze/bfg/zcml.py b/repoze/bfg/zcml.py
index 94bb7371d..a9a6a95a0 100644
--- a/repoze/bfg/zcml.py
+++ b/repoze/bfg/zcml.py
@@ -182,7 +182,7 @@ def view(
 
     def register():
         derived_view = derive_view(view, permission, predicates, attr, renderer,
-                                   wrapper)
+                                   wrapper, name)
         r_for_ = for_
         r_request_type = request_type
         if r_for_ is None:
@@ -252,15 +252,15 @@ def forbidden(_context, view):
     view_utility(_context, view, IForbiddenView)
 
 def derive_view(original_view, permission=None, predicates=(), attr=None,
-                renderer=None, wrapper_viewname=None):
+                renderer=None, wrapper_viewname=None, viewname=None):
     mapped_view = map_view(original_view, attr, renderer)
-    owrapped_view = owrap_view(mapped_view, wrapper_viewname)
+    owrapped_view = owrap_view(mapped_view, viewname, wrapper_viewname)
     secured_view = secure_view(owrapped_view, permission)
     debug_view = authdebug_view(secured_view, permission)
     derived_view = predicate_wrap(debug_view, predicates)
     return derived_view
 
-def owrap_view(view, wrapper_viewname):
+def owrap_view(view, viewname, wrapper_viewname):
     if not wrapper_viewname:
         return view
     def _owrapped_view(context, request):
@@ -268,7 +268,13 @@ def owrap_view(view, wrapper_viewname):
         request.wrapped_response = response
         request.wrapped_body = response.body
         request.wrapped_view = view
-        return render_view_to_response(context, request, wrapper_viewname)
+        wrapped_response = render_view_to_response(context, request,
+                                                   wrapper_viewname)
+        if wrapped_response is None:
+            raise ValueError(
+                'No wrapper view named %r found when executing view named %r' %
+                             (wrapper_viewname, viewname))
+        return wrapped_response
     decorate_view(_owrapped_view, view)
     return _owrapped_view