From 470737a5f5a7d86b809b260b9dbc09f266d4b69c Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Wed, 16 Sep 2009 18:25:31 +0000 Subject: - 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. --- repoze/bfg/testing.py | 16 ++++++++++------ repoze/bfg/tests/test_testing.py | 8 ++++---- repoze/bfg/tests/test_zcml.py | 13 ++++++++++++- repoze/bfg/zcml.py | 16 +++++++++++----- 4 files changed, 37 insertions(+), 16 deletions(-) (limited to 'repoze') 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 -- cgit v1.2.3