From 2a264f946dd98ab423b458ba8e2c1ec3b55052e1 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Sat, 21 Nov 2009 03:57:56 +0000 Subject: Turn wrapper methods back into functions to avoid keeping around references to Configurator in closures. --- repoze/bfg/configuration.py | 409 +++++----- repoze/bfg/path.py | 2 +- repoze/bfg/tests/test_configuration.py | 1268 ++++++++++++++++---------------- repoze/bfg/zcml.py | 36 +- 4 files changed, 850 insertions(+), 865 deletions(-) diff --git a/repoze/bfg/configuration.py b/repoze/bfg/configuration.py index b272bee52..3d4f477e9 100644 --- a/repoze/bfg/configuration.py +++ b/repoze/bfg/configuration.py @@ -67,26 +67,20 @@ class Configurator(object): """ A wrapper around the registry that performs configuration tasks """ def __init__(self, registry=None): self.package = caller_package() - if registry is None: - registry = self.make_default_registry() self.reg = registry - try: - # yes, a cycle; see get_configurator - self.reg['bfg_configurator'] = self - except TypeError: - pass + if registry is None: + registry = Registry(self.package.__name__) + self.reg = registry + self._default_configuration() - def make_default_registry(self): - self.reg = Registry() + def _default_configuration(self): self.renderer(chameleon_zpt.renderer_factory, '.pt') self.renderer(chameleon_text.renderer_factory, '.txt') self.renderer(renderers.json_renderer_factory, 'json') self.renderer(renderers.string_renderer_factory, 'string') - settings = Settings({}) - self.settings(settings) + self.settings(Settings({})) self.root_factory(DefaultRootFactory) self.debug_logger(None) - return self.reg def make_wsgi_app(self, manager=manager, getSiteManager=getSiteManager): # manager and getSiteManager in arglist for testing dep injection only @@ -109,7 +103,7 @@ class Configurator(object): settings=None, debug_logger=None, os=os, lock=threading.Lock()): - self.make_default_registry() + self._default_configuration() # debug_logger, os and lock *only* for unittests if settings is None: @@ -243,213 +237,38 @@ class Configurator(object): self.reg.registerAdapter(multiview, (for_, request_type), IMultiView, name, info=_info) + def derive_view(self, view, permission=None, predicates=(), + attr=None, renderer_name=None, wrapper_viewname=None, + viewname=None): + renderer = self.renderer_from_name(renderer_name) + reg = self.reg + mapped_view = _map_view(reg, view, attr, renderer, renderer_name) + owrapped_view = _owrap_view(reg, mapped_view, viewname,wrapper_viewname) + secured_view = _secure_view(reg, owrapped_view, permission) + debug_view = _authdebug_view(reg, secured_view, permission) + derived_view = _predicate_wrap(reg, debug_view, predicates) + return derived_view + def renderer_from_name(self, path_or_spec): + if path_or_spec is None: + # check for global default renderer + factory = self.reg.queryUtility(IRendererFactory) + if factory is not None: + return factory(path_or_spec) + return None + if '.' in path_or_spec: name = os.path.splitext(path_or_spec)[1] spec = self.make_spec(path_or_spec) else: name = path_or_spec spec = path_or_spec + factory = self.reg.queryUtility(IRendererFactory, name=name) if factory is None: raise ValueError('No renderer for renderer name %r' % name) return factory(spec) - def derive_view(self, original_view, permission=None, predicates=(), - attr=None, renderer_name=None, wrapper_viewname=None, - viewname=None): - mapped_view = self._map_view(original_view, attr, renderer_name) - owrapped_view = self._owrap_view(mapped_view, viewname,wrapper_viewname) - secured_view = self._secure_view(owrapped_view, permission) - debug_view = self._authdebug_view(secured_view, permission) - derived_view = self._predicate_wrap(debug_view, predicates) - return derived_view - - def _map_view(self, view, attr=None, renderer_name=None): - wrapped_view = view - - renderer = None - - if renderer_name is None: - # global default renderer - factory = self.reg.queryUtility(IRendererFactory) - if factory is not None: - renderer_name = '' - renderer = factory(renderer_name) - else: - renderer = self.renderer_from_name(renderer_name) - - if inspect.isclass(view): - # If the object we've located is a class, turn it into a - # function that operates like a Zope view (when it's invoked, - # construct an instance using 'context' and 'request' as - # position arguments, then immediately invoke the __call__ - # method of the instance with no arguments; __call__ should - # return an IResponse). - if requestonly(view, attr): - # its __init__ accepts only a single request argument, - # instead of both context and request - def _bfg_class_requestonly_view(context, request): - inst = view(request) - if attr is None: - response = inst() - else: - response = getattr(inst, attr)() - if renderer is not None: - response = rendered_response(renderer, - response, inst, - context, request, - renderer_name) - return response - wrapped_view = _bfg_class_requestonly_view - else: - # its __init__ accepts both context and request - def _bfg_class_view(context, request): - inst = view(context, request) - if attr is None: - response = inst() - else: - response = getattr(inst, attr)() - if renderer is not None: - response = rendered_response(renderer, - response, inst, - context, request, - renderer_name) - return response - wrapped_view = _bfg_class_view - - elif requestonly(view, attr): - # its __call__ accepts only a single request argument, - # instead of both context and request - def _bfg_requestonly_view(context, request): - if attr is None: - response = view(request) - else: - response = getattr(view, attr)(request) - - if renderer is not None: - response = rendered_response(renderer, - response, view, - context, request, - renderer_name) - return response - wrapped_view = _bfg_requestonly_view - - elif attr: - def _bfg_attr_view(context, request): - response = getattr(view, attr)(context, request) - if renderer is not None: - response = rendered_response(renderer, - response, view, - context, request, - renderer_name) - return response - wrapped_view = _bfg_attr_view - - elif renderer is not None: - def _rendered_view(context, request): - response = view(context, request) - response = rendered_response(renderer, - response, view, - context, request, - renderer_name) - return response - wrapped_view = _rendered_view - - decorate_view(wrapped_view, view) - return wrapped_view - - def _owrap_view(self, view, viewname, wrapper_viewname): - if not wrapper_viewname: - return view - def _owrapped_view(context, request): - response = view(context, request) - request.wrapped_response = response - request.wrapped_body = response.body - request.wrapped_view = view - 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 - - def _predicate_wrap(self, view, predicates): - if not predicates: - return view - def _wrapped(context, request): - if all((predicate(context, request) for predicate in predicates)): - return view(context, request) - raise NotFound('predicate mismatch for view %s' % view) - def checker(context, request): - return all((predicate(context, request) for predicate in - predicates)) - _wrapped.__predicated__ = checker - decorate_view(_wrapped, view) - return _wrapped - - def _secure_view(self, view, permission): - wrapped_view = view - authn_policy = self.reg.queryUtility(IAuthenticationPolicy) - authz_policy = self.reg.queryUtility(IAuthorizationPolicy) - if authn_policy and authz_policy and (permission is not None): - def _secured_view(context, request): - principals = authn_policy.effective_principals(request) - if authz_policy.permits(context, principals, permission): - return view(context, request) - msg = getattr(request, 'authdebug_message', - 'Unauthorized: %s failed permission check' % view) - raise Forbidden(msg) - _secured_view.__call_permissive__ = view - def _permitted(context, request): - principals = authn_policy.effective_principals(request) - return authz_policy.permits(context, principals, permission) - _secured_view.__permitted__ = _permitted - wrapped_view = _secured_view - decorate_view(wrapped_view, view) - - return wrapped_view - - def _authdebug_view(self, view, permission): - wrapped_view = view - authn_policy = self.reg.queryUtility(IAuthenticationPolicy) - authz_policy = self.reg.queryUtility(IAuthorizationPolicy) - settings = self.reg.queryUtility(ISettings) - debug_authorization = False - if settings is not None: - debug_authorization = settings.get('debug_authorization', False) - if debug_authorization: - def _authdebug_view(context, request): - view_name = getattr(request, 'view_name', None) - - if authn_policy and authz_policy: - if permission is None: - msg = 'Allowed (no permission registered)' - else: - principals = authn_policy.effective_principals(request) - msg = str(authz_policy.permits(context, principals, - permission)) - else: - msg = 'Allowed (no authorization policy in use)' - - view_name = getattr(request, 'view_name', None) - url = getattr(request, 'url', None) - msg = ('debug_authorization of url %s (view name %r against ' - 'context %r): %s' % (url, view_name, context, msg)) - logger = self.reg.queryUtility(ILogger, 'repoze.bfg.debug') - logger and logger.debug(msg) - if request is not None: - request.authdebug_message = msg - return view(context, request) - - wrapped_view = _authdebug_view - decorate_view(wrapped_view, view) - - return wrapped_view - def route(self, name, path, view=None, view_for=None, permission=None, factory=None, for_=None, header=None, xhr=False, accept=None, path_info=None, @@ -869,3 +688,177 @@ def requestonly(class_or_callable, attr=None): return False +def _map_view(registry, view, attr=None, renderer=None, renderer_name=None): + wrapped_view = view + + if inspect.isclass(view): + # If the object we've located is a class, turn it into a + # function that operates like a Zope view (when it's invoked, + # construct an instance using 'context' and 'request' as + # position arguments, then immediately invoke the __call__ + # method of the instance with no arguments; __call__ should + # return an IResponse). + if requestonly(view, attr): + # its __init__ accepts only a single request argument, + # instead of both context and request + def _bfg_class_requestonly_view(context, request): + inst = view(request) + if attr is None: + response = inst() + else: + response = getattr(inst, attr)() + if renderer is not None: + response = rendered_response(renderer, + response, inst, + context, request, + renderer_name) + return response + wrapped_view = _bfg_class_requestonly_view + else: + # its __init__ accepts both context and request + def _bfg_class_view(context, request): + inst = view(context, request) + if attr is None: + response = inst() + else: + response = getattr(inst, attr)() + if renderer is not None: + response = rendered_response(renderer, + response, inst, + context, request, + renderer_name) + return response + wrapped_view = _bfg_class_view + + elif requestonly(view, attr): + # its __call__ accepts only a single request argument, + # instead of both context and request + def _bfg_requestonly_view(context, request): + if attr is None: + response = view(request) + else: + response = getattr(view, attr)(request) + + if renderer is not None: + response = rendered_response(renderer, + response, view, + context, request, + renderer_name) + return response + wrapped_view = _bfg_requestonly_view + + elif attr: + def _bfg_attr_view(context, request): + response = getattr(view, attr)(context, request) + if renderer is not None: + response = rendered_response(renderer, + response, view, + context, request, + renderer_name) + return response + wrapped_view = _bfg_attr_view + + elif renderer is not None: + def _rendered_view(context, request): + response = view(context, request) + response = rendered_response(renderer, + response, view, + context, request, + renderer_name) + return response + wrapped_view = _rendered_view + + decorate_view(wrapped_view, view) + return wrapped_view + +def _owrap_view(registry, view, viewname, wrapper_viewname): + if not wrapper_viewname: + return view + def _owrapped_view(context, request): + response = view(context, request) + request.wrapped_response = response + request.wrapped_body = response.body + request.wrapped_view = view + 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 + +def _predicate_wrap(registry, view, predicates): + if not predicates: + return view + def _wrapped(context, request): + if all((predicate(context, request) for predicate in predicates)): + return view(context, request) + raise NotFound('predicate mismatch for view %s' % view) + def checker(context, request): + return all((predicate(context, request) for predicate in + predicates)) + _wrapped.__predicated__ = checker + decorate_view(_wrapped, view) + return _wrapped + +def _secure_view(registry, view, permission): + wrapped_view = view + authn_policy = registry.queryUtility(IAuthenticationPolicy) + authz_policy = registry.queryUtility(IAuthorizationPolicy) + if authn_policy and authz_policy and (permission is not None): + def _secured_view(context, request): + principals = authn_policy.effective_principals(request) + if authz_policy.permits(context, principals, permission): + return view(context, request) + msg = getattr(request, 'authdebug_message', + 'Unauthorized: %s failed permission check' % view) + raise Forbidden(msg) + _secured_view.__call_permissive__ = view + def _permitted(context, request): + principals = authn_policy.effective_principals(request) + return authz_policy.permits(context, principals, permission) + _secured_view.__permitted__ = _permitted + wrapped_view = _secured_view + decorate_view(wrapped_view, view) + + return wrapped_view + +def _authdebug_view(registry, view, permission): + wrapped_view = view + authn_policy = registry.queryUtility(IAuthenticationPolicy) + authz_policy = registry.queryUtility(IAuthorizationPolicy) + settings = registry.queryUtility(ISettings) + debug_authorization = False + if settings is not None: + debug_authorization = settings.get('debug_authorization', False) + if debug_authorization: + def _authdebug_view(context, request): + view_name = getattr(request, 'view_name', None) + + if authn_policy and authz_policy: + if permission is None: + msg = 'Allowed (no permission registered)' + else: + principals = authn_policy.effective_principals(request) + msg = str(authz_policy.permits(context, principals, + permission)) + else: + msg = 'Allowed (no authorization policy in use)' + + view_name = getattr(request, 'view_name', None) + url = getattr(request, 'url', None) + msg = ('debug_authorization of url %s (view name %r against ' + 'context %r): %s' % (url, view_name, context, msg)) + logger =registry.queryUtility(ILogger, 'repoze.bfg.debug') + logger and logger.debug(msg) + if request is not None: + request.authdebug_message = msg + return view(context, request) + + wrapped_view = _authdebug_view + decorate_view(wrapped_view, view) + + return wrapped_view + diff --git a/repoze/bfg/path.py b/repoze/bfg/path.py index cdc0cd1ea..b4ff40494 100644 --- a/repoze/bfg/path.py +++ b/repoze/bfg/path.py @@ -34,7 +34,7 @@ def package_name(pkg_or_module): def caller_package(level=2, caller_module=caller_module): # caller_module in arglist for tests module = caller_module(level+1) - if '__init__.py' in module.__file__: + if '__init__.py' in getattr(module, '__file__', ''): # empty at >>> # Module is a package return module # Go up one level to get package diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py index e427823fa..802f21915 100644 --- a/repoze/bfg/tests/test_configuration.py +++ b/repoze/bfg/tests/test_configuration.py @@ -96,10 +96,14 @@ class ConfiguratorTests(unittest.TestCase): config = Configurator() self.failUnless(config.reg.getUtility(ISettings)) - def test_make_default_registry(self): - config = self._makeOne() - reg = config.make_default_registry() - self.assertEqual(config.reg, reg) + def test__default_configuration(self): + from repoze.bfg.interfaces import ISettings + from repoze.bfg.registry import Registry + registry = Registry() + config = self._makeOne(registry) + config._default_configuration() + self.assertEqual(config.reg, registry) + self.failIf(config.reg.getUtility(ISettings) is None) def test_make_wsgi_app(self): from repoze.bfg.threadlocal import get_current_registry @@ -939,825 +943,825 @@ class ConfiguratorTests(unittest.TestCase): route = self._assertRoute(config, 'name', 'path') self.failUnless(hasattr(wrapper, '__call_permissive__')) - def test__map_view_as_function_context_and_request(self): - def view(context, request): - return 'OK' + def test__override_not_yet_registered(self): + from repoze.bfg.interfaces import IPackageOverrides + package = DummyPackage('package') + opackage = DummyPackage('opackage') config = self._makeOne() - result = config._map_view(view) - self.failUnless(result is view) - self.assertEqual(result(None, None), 'OK') + config._override(package, 'path', opackage, 'oprefix', + PackageOverrides=DummyOverrides) + overrides = config.reg.queryUtility(IPackageOverrides, + name='package') + self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) + self.assertEqual(overrides.package, package) - def test__map_view_as_function_with_attr(self): - def view(context, request): - """ """ + def test__override_already_registered(self): + from repoze.bfg.interfaces import IPackageOverrides + package = DummyPackage('package') + opackage = DummyPackage('opackage') + overrides = DummyOverrides(package) config = self._makeOne() - result = config._map_view(view, attr='__name__') - self.failIf(result is view) - self.assertRaises(TypeError, result, None, None) + config.reg.registerUtility(overrides, IPackageOverrides, + name='package') + config._override(package, 'path', opackage, 'oprefix', + PackageOverrides=DummyOverrides) + self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) + self.assertEqual(overrides.package, package) - def test__map_view_as_function_with_attr_and_renderer(self): + def test_static_here_relative(self): + from repoze.bfg.static import PackageURLParser + from zope.interface import implementedBy + from repoze.bfg.static import StaticRootFactory + from repoze.bfg.interfaces import IView config = self._makeOne() - self._registerRenderer(config) - view = lambda *arg: 'OK' - result = config._map_view(view, attr='__name__', - renderer_name='fixtures/minimal.txt') - self.failIf(result is view) - self.assertRaises(TypeError, result, None, None) - - def test__map_view_as_function_requestonly(self): + config.static('static', 'fixtures/static') + request_type = self._getRouteRequestIface(config, 'static') + route = self._assertRoute(config, 'static', 'static*subpath') + self.assertEqual(route.factory.__class__, StaticRootFactory) + iface = implementedBy(StaticRootFactory) + wrapped = config.reg.adapters.lookup( + (iface, request_type), IView, name='') + request = self._makeRequest(config) + self.assertEqual(wrapped(None, request).__class__, PackageURLParser) + + def test_static_package_relative(self): + from repoze.bfg.static import PackageURLParser + from zope.interface import implementedBy + from repoze.bfg.static import StaticRootFactory + from repoze.bfg.interfaces import IView config = self._makeOne() - def view(request): - return 'OK' - result = config._map_view(view) - 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') + config.static('static', 'repoze.bfg.tests:fixtures/static') + request_type = self._getRouteRequestIface(config, 'static') + route = self._assertRoute(config, 'static', 'static*subpath') + self.assertEqual(route.factory.__class__, StaticRootFactory) + iface = implementedBy(StaticRootFactory) + wrapped = config.reg.adapters.lookup( + (iface, request_type), IView, name='') + request = self._makeRequest(config) + self.assertEqual(wrapped(None, request).__class__, PackageURLParser) - def test__map_view_as_function_requestonly_with_attr(self): + def test_static_absolute(self): + from paste.urlparser import StaticURLParser + import os + from zope.interface import implementedBy + from repoze.bfg.static import StaticRootFactory + from repoze.bfg.interfaces import IView config = self._makeOne() - def view(request): - """ """ - result = config._map_view(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) + here = os.path.dirname(__file__) + static_path = os.path.join(here, 'fixtures', 'static') + config.static('static', static_path) + request_type = self._getRouteRequestIface(config, 'static') + route = self._assertRoute(config, 'static', 'static*subpath') + self.assertEqual(route.factory.__class__, StaticRootFactory) + iface = implementedBy(StaticRootFactory) + wrapped = config.reg.adapters.lookup( + (iface, request_type), IView, name='') + request = self._makeRequest(config) + self.assertEqual(wrapped(None, request).__class__, StaticURLParser) - def test__map_view_as_newstyle_class_context_and_request(self): + def test_system_view_no_view_no_renderer(self): + from zope.configuration.exceptions import ConfigurationError config = self._makeOne() - class view(object): - def __init__(self, context, request): - pass - def __call__(self): - return 'OK' - result = config._map_view(view) - 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') + self.assertRaises(ConfigurationError, config.system_view, IDummy) - def test__map_view_as_newstyle_class_context_and_request_with_attr(self): + def test_system_view_no_view_with_renderer(self): + config = self._makeOne() + self._registerRenderer(config, name='.pt') + config.system_view(IDummy, + renderer='repoze.bfg.tests:fixtures/minimal.pt') + request = self._makeRequest(config) + view = config.reg.getUtility(IDummy) + result = view(None, request) + self.assertEqual(result.body, 'Hello!') + + def test_system_view_with_attr(self): config = self._makeOne() class view(object): def __init__(self, context, request): pass def index(self): return 'OK' - result = config._map_view(view, attr='index') + config.system_view(IDummy, view=view, attr='index') + view = config.reg.getUtility(IDummy) + request = self._makeRequest(config) + result = view(None, request) + self.assertEqual(result, 'OK') + + def test_system_view_with_wrapper(self): + from zope.interface import Interface + from zope.interface import directlyProvides + from repoze.bfg.interfaces import IRequest + from repoze.bfg.interfaces import IView + config = self._makeOne() + view = lambda *arg: DummyResponse() + wrapper = lambda *arg: 'OK2' + config.reg.registerAdapter(wrapper, (Interface, Interface), + IView, name='wrapper') + config.system_view(IDummy, view=view, wrapper='wrapper') + view = config.reg.getUtility(IDummy) + request = self._makeRequest(config) + directlyProvides(request, IRequest) + request.registry = config.reg + context = DummyContext() + result = view(context, request) + self.assertEqual(result, 'OK2') + + def test_notfound(self): + from repoze.bfg.interfaces import INotFoundView + config = self._makeOne() + view = lambda *arg: 'OK' + config.notfound(view) + request = self._makeRequest(config) + view = config.reg.getUtility(INotFoundView) + result = view(None, request) + self.assertEqual(result, 'OK') + + def test_forbidden(self): + from repoze.bfg.interfaces import IForbiddenView + config = self._makeOne() + view = lambda *arg: 'OK' + config.forbidden(view) + request = self._makeRequest(config) + view = config.reg.getUtility(IForbiddenView) + result = view(None, request) + self.assertEqual(result, 'OK') + + def test_authentication_policy(self): + from repoze.bfg.interfaces import IAuthenticationPolicy + config = self._makeOne() + policy = object() + config.authentication_policy(policy) + self.assertEqual(config.reg.getUtility(IAuthenticationPolicy), policy) + + def test_authorization_policy(self): + from repoze.bfg.interfaces import IAuthorizationPolicy + config = self._makeOne() + policy = object() + config.authorization_policy(policy) + self.assertEqual(config.reg.getUtility(IAuthorizationPolicy), policy) + + def test_derive_view_as_function_context_and_request(self): + def view(context, request): + return 'OK' + config = self._makeOne() + result = config.derive_view(view) + self.failUnless(result is view) + self.failIf(hasattr(result, '__call_permissive__')) + self.assertEqual(view(None, None), 'OK') + + def test_derive_view_as_function_requestonly(self): + def view(request): + return 'OK' + config = self._makeOne() + result = config.derive_view(view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test__map_view_as_newstyle_class_context_and_request_attr_and_renderer( - self): - config = self._makeOne() - self._registerRenderer(config) + def test_derive_view_as_newstyle_class_context_and_request(self): class view(object): def __init__(self, context, request): pass - def index(self): - return {'a':'1'} - result = config._map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + def __call__(self): + return 'OK' + config = self._makeOne() + result = config.derive_view(view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - request = self._makeRequest(config) - self.assertEqual(result(None, request).body, 'Hello!') + self.failIf(hasattr(result, '__call_permissive__')) + self.assertEqual(result(None, None), 'OK') - def test__map_view_as_newstyle_class_requestonly(self): - config = self._makeOne() + def test_derive_view_as_newstyle_class_requestonly(self): class view(object): - def __init__(self, request): + def __init__(self, context, request): pass def __call__(self): return 'OK' - result = config._map_view(view) + config = self._makeOne() + result = config.derive_view(view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test__map_view_as_newstyle_class_requestonly_with_attr(self): - config = self._makeOne() - class view(object): - def __init__(self, request): + def test_derive_view_as_oldstyle_class_context_and_request(self): + class view: + def __init__(self, context, request): pass - def index(self): + def __call__(self): return 'OK' - result = config._map_view(view, attr='index') + config = self._makeOne() + result = config.derive_view(view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - - def test__map_view_as_newstyle_class_requestonly_with_attr_and_renderer( - self): - config = self._makeOne() - self._registerRenderer(config) - class view(object): - def __init__(self, request): + + def test_derive_view_as_oldstyle_class_requestonly(self): + class view: + def __init__(self, context, request): pass - def index(self): - return {'a':'1'} - result = config._map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + def __call__(self): + return 'OK' + config = self._makeOne() + result = config.derive_view(view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - request = self._makeRequest(config) - self.assertEqual(result(None, request).body, 'Hello!') + self.failIf(hasattr(result, '__call_permissive__')) + self.assertEqual(result(None, None), 'OK') - def test__map_view_as_oldstyle_class_context_and_request(self): + def test_derive_view_as_instance_context_and_request(self): + class View: + def __call__(self, context, request): + return 'OK' + view = View() config = self._makeOne() - class view: - def __init__(self, context, request): - pass - def __call__(self): + result = config.derive_view(view) + self.failUnless(result is view) + self.failIf(hasattr(result, '__call_permissive__')) + self.assertEqual(result(None, None), 'OK') + + def test_derive_view_as_instance_requestonly(self): + class View: + def __call__(self, request): return 'OK' - result = config._map_view(view) + view = View() + config = self._makeOne() + result = config.derive_view(view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) + self.failUnless('instance' in result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test__map_view_as_oldstyle_class_context_and_request_with_attr(self): + def test_derive_view_with_debug_authorization_no_authpol(self): + view = lambda *arg: 'OK' config = self._makeOne() - class view: - def __init__(self, context, request): - pass - def index(self): - return 'OK' - result = config._map_view(view, attr='index') - self.failIf(result is view) + self._registerSettings(config, + debug_authorization=True, reload_templates=True) + logger = self._registerLogger(config) + result = config.derive_view(view, permission='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') + self.failIf(hasattr(result, '__call_permissive__')) + request = self._makeRequest(config) + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): Allowed " + "(no authorization policy in use)") - def test__map_view_as_oldstyle_class_context_and_request_attr_and_renderer( - self): + def test_derive_view_with_debug_authorization_no_permission(self): + view = lambda *arg: 'OK' config = self._makeOne() - self._registerRenderer(config) - class view: - def __init__(self, context, request): - pass - def index(self): - return {'a':'1'} - result = config._map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) + self._registerSettings(config, + debug_authorization=True, reload_templates=True) + self._registerSecurityPolicy(config, True) + logger = self._registerLogger(config) + result = config.derive_view(view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) request = self._makeRequest(config) - self.assertEqual(result(None, request).body, 'Hello!') + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): Allowed (" + "no permission registered)") - def test__map_view_as_oldstyle_class_requestonly(self): + def test_derive_view_debug_authorization_permission_authpol_permitted(self): + view = lambda *arg: 'OK' config = self._makeOne() - class view: - def __init__(self, request): - pass - def __call__(self): - return 'OK' - result = config._map_view(view) - self.failIf(result is view) + self._registerSettings(config, debug_authorization=True, + reload_templates=True) + logger = self._registerLogger(config) + self._registerSecurityPolicy(config, True) + result = config.derive_view(view, permission='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__map_view_as_oldstyle_class_requestonly_with_attr(self): + self.assertEqual(result.__call_permissive__, view) + request = self._makeRequest(config) + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): True") + + def test_derive_view_debug_authorization_permission_authpol_denied(self): + from repoze.bfg.exceptions import Forbidden + view = lambda *arg: 'OK' config = self._makeOne() - class view: - def __init__(self, request): - pass - def index(self): - return 'OK' - result = config._map_view(view, attr='index') - self.failIf(result is view) + self._registerSettings(config, + debug_authorization=True, reload_templates=True) + logger = self._registerLogger(config) + self._registerSecurityPolicy(config, False) + result = config.derive_view(view, permission='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') + self.assertEqual(result.__call_permissive__, view) + request = self._makeRequest(config) + request.view_name = 'view_name' + request.url = 'url' + self.assertRaises(Forbidden, result, None, request) + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): False") - def test__map_view_as_oldstyle_class_requestonly_attr_and_renderer(self): + def test_derive_view_debug_authorization_permission_authpol_denied2(self): + view = lambda *arg: 'OK' config = self._makeOne() - self._registerRenderer(config) - class view: - def __init__(self, request): - pass - def index(self): - return {'a':'1'} - result = config._map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) + self._registerSettings(config, + debug_authorization=True, reload_templates=True) + logger = self._registerLogger(config) + self._registerSecurityPolicy(config, False) + result = config.derive_view(view, permission='view') self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) request = self._makeRequest(config) - self.assertEqual(result(None, request).body, 'Hello!') + request.view_name = 'view_name' + request.url = 'url' + permitted = result.__permitted__(None, None) + self.assertEqual(permitted, False) - def test__map_view_as_instance_context_and_request(self): + def test_derive_view_with_predicates_all(self): + view = lambda *arg: 'OK' + predicates = [] + def predicate1(context, request): + predicates.append(True) + return True + def predicate2(context, request): + predicates.append(True) + return True config = self._makeOne() - class View: - def __call__(self, context, request): - return 'OK' - view = View() - result = config._map_view(view) - self.failUnless(result is view) - self.assertEqual(result(None, None), 'OK') - - def test__map_view_as_instance_context_and_request_and_attr(self): + result = config.derive_view(view, predicates=[predicate1, predicate2]) + request = self._makeRequest(config) + request.method = 'POST' + next = result(None, None) + self.assertEqual(next, 'OK') + self.assertEqual(predicates, [True, True]) + + def test_derive_view_with_predicates_checker(self): + view = lambda *arg: 'OK' + predicates = [] + def predicate1(context, request): + predicates.append(True) + return True + def predicate2(context, request): + predicates.append(True) + return True config = self._makeOne() - class View: - def index(self, context, request): - return 'OK' - view = View() - result = config._map_view(view, attr='index') - self.failIf(result is view) - self.assertEqual(result(None, None), 'OK') + result = config.derive_view(view, predicates=[predicate1, predicate2]) + request = self._makeRequest(config) + request.method = 'POST' + next = result.__predicated__(None, None) + self.assertEqual(next, True) + self.assertEqual(predicates, [True, True]) - def test__map_view_as_instance_context_and_request_attr_and_renderer(self): + def test_derive_view_with_predicates_notall(self): + from repoze.bfg.exceptions import NotFound + view = lambda *arg: 'OK' + predicates = [] + def predicate1(context, request): + predicates.append(True) + return True + def predicate2(context, request): + predicates.append(True) + return False config = self._makeOne() - self._registerRenderer(config) - class View: - def index(self, context, request): - return {'a':'1'} - view = View() - result = config._map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) + result = config.derive_view(view, predicates=[predicate1, predicate2]) request = self._makeRequest(config) - self.assertEqual(result(None, request).body, 'Hello!') + request.method = 'POST' + self.assertRaises(NotFound, result, None, None) + self.assertEqual(predicates, [True, True]) - def test__map_view_as_instance_requestonly(self): + def test_derive_view_with_wrapper_viewname(self): + from webob import Response + from repoze.bfg.interfaces import IView + inner_response = Response('OK') + def inner_view(context, request): + return inner_response + def outer_view(context, request): + self.assertEqual(request.wrapped_response, inner_response) + self.assertEqual(request.wrapped_body, inner_response.body) + self.assertEqual(request.wrapped_view, inner_view) + return Response('outer ' + request.wrapped_body) config = self._makeOne() - class View: - def __call__(self, request): - return 'OK' - view = View() - result = config._map_view(view) - 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') + config.reg.registerAdapter(outer_view, (None, None), IView, 'owrap') + result = config.derive_view(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__) + request = self._makeRequest(config) + request.registry = config.reg + response = result(None, request) + self.assertEqual(response.body, 'outer OK') - def test__map_view_as_instance_requestonly_with_attr(self): + def test_derive_view_with_wrapper_viewname_notfound(self): + from webob import Response + inner_response = Response('OK') + def inner_view(context, request): + return inner_response config = self._makeOne() - class View: - def index(self, request): - return 'OK' - view = View() - result = config._map_view(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__map_view_as_instance_requestonly_with_attr_and_renderer(self): - config = self._makeOne() - self._registerRenderer(config) - class View: - def index(self, request): - return {'a':'1'} - view = View() - result = config._map_view( - view, attr='index', - renderer_name='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__) - request = self._makeRequest(config) - self.assertEqual(result(None, request).body, 'Hello!') - - def test__map_view_rendereronly(self): - config = self._makeOne() - self._registerRenderer(config) - def view(context, request): - return {'a':'1'} - result = config._map_view( - view, - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - request = self._makeRequest(config) - self.assertEqual(result(None, request).body, 'Hello!') - - def test__map_view_defaultrendereronly(self): - config = self._makeOne() - self._registerRenderer(config, name='') - def view(context, request): - return {'a':'1'} - result = config._map_view(view) - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - request = self._makeRequest(config) - self.assertEqual(result(None, request).body, 'Hello!') - - def test__override_not_yet_registered(self): - from repoze.bfg.interfaces import IPackageOverrides - package = DummyPackage('package') - opackage = DummyPackage('opackage') - config = self._makeOne() - config._override(package, 'path', opackage, 'oprefix', - PackageOverrides=DummyOverrides) - overrides = config.reg.queryUtility(IPackageOverrides, - name='package') - self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) - self.assertEqual(overrides.package, package) - - def test__override_already_registered(self): - from repoze.bfg.interfaces import IPackageOverrides - package = DummyPackage('package') - opackage = DummyPackage('opackage') - overrides = DummyOverrides(package) - config = self._makeOne() - config.reg.registerUtility(overrides, IPackageOverrides, - name='package') - config._override(package, 'path', opackage, 'oprefix', - PackageOverrides=DummyOverrides) - self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) - self.assertEqual(overrides.package, package) - - def test_static_here_relative(self): - from repoze.bfg.static import PackageURLParser - from zope.interface import implementedBy - from repoze.bfg.static import StaticRootFactory - from repoze.bfg.interfaces import IView - config = self._makeOne() - config.static('static', 'fixtures/static') - request_type = self._getRouteRequestIface(config, 'static') - route = self._assertRoute(config, 'static', 'static*subpath') - self.assertEqual(route.factory.__class__, StaticRootFactory) - iface = implementedBy(StaticRootFactory) - wrapped = config.reg.adapters.lookup( - (iface, request_type), IView, name='') - request = self._makeRequest(config) - self.assertEqual(wrapped(None, request).__class__, PackageURLParser) - - def test_static_package_relative(self): - from repoze.bfg.static import PackageURLParser - from zope.interface import implementedBy - from repoze.bfg.static import StaticRootFactory - from repoze.bfg.interfaces import IView - config = self._makeOne() - config.static('static', 'repoze.bfg.tests:fixtures/static') - request_type = self._getRouteRequestIface(config, 'static') - route = self._assertRoute(config, 'static', 'static*subpath') - self.assertEqual(route.factory.__class__, StaticRootFactory) - iface = implementedBy(StaticRootFactory) - wrapped = config.reg.adapters.lookup( - (iface, request_type), IView, name='') - request = self._makeRequest(config) - self.assertEqual(wrapped(None, request).__class__, PackageURLParser) - - def test_static_absolute(self): - from paste.urlparser import StaticURLParser - import os - from zope.interface import implementedBy - from repoze.bfg.static import StaticRootFactory - from repoze.bfg.interfaces import IView - config = self._makeOne() - here = os.path.dirname(__file__) - static_path = os.path.join(here, 'fixtures', 'static') - config.static('static', static_path) - request_type = self._getRouteRequestIface(config, 'static') - route = self._assertRoute(config, 'static', 'static*subpath') - self.assertEqual(route.factory.__class__, StaticRootFactory) - iface = implementedBy(StaticRootFactory) - wrapped = config.reg.adapters.lookup( - (iface, request_type), IView, name='') request = self._makeRequest(config) - self.assertEqual(wrapped(None, request).__class__, StaticURLParser) + request.registry = config.reg + wrapped = config.derive_view( + inner_view, viewname='inner', wrapper_viewname='owrap') + result = self.assertRaises(ValueError, wrapped, None, request) - def test_system_view_no_view_no_renderer(self): + def test_resource_samename(self): from zope.configuration.exceptions import ConfigurationError config = self._makeOne() - self.assertRaises(ConfigurationError, config.system_view, IDummy) - - def test_system_view_no_view_with_renderer(self): - config = self._makeOne() - self._registerRenderer(config, name='.pt') - config.system_view(IDummy, - renderer='repoze.bfg.tests:fixtures/minimal.pt') - request = self._makeRequest(config) - view = config.reg.getUtility(IDummy) - result = view(None, request) - self.assertEqual(result.body, 'Hello!') + self.assertRaises(ConfigurationError, config.resource, 'a', 'a') - def test_system_view_with_attr(self): + def test_resource_override_directory_with_file(self): + from zope.configuration.exceptions import ConfigurationError config = self._makeOne() - class view(object): - def __init__(self, context, request): - pass - def index(self): - return 'OK' - config.system_view(IDummy, view=view, attr='index') - view = config.reg.getUtility(IDummy) - request = self._makeRequest(config) - result = view(None, request) - self.assertEqual(result, 'OK') + self.assertRaises(ConfigurationError, config.resource, + 'a:foo/', 'a:foo.pt') - def test_system_view_with_wrapper(self): - from zope.interface import Interface - from zope.interface import directlyProvides - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView + def test_resource_override_file_with_directory(self): + from zope.configuration.exceptions import ConfigurationError config = self._makeOne() - view = lambda *arg: DummyResponse() - wrapper = lambda *arg: 'OK2' - config.reg.registerAdapter(wrapper, (Interface, Interface), - IView, name='wrapper') - config.system_view(IDummy, view=view, wrapper='wrapper') - view = config.reg.getUtility(IDummy) - request = self._makeRequest(config) - directlyProvides(request, IRequest) - request.registry = config.reg - context = DummyContext() - result = view(context, request) - self.assertEqual(result, 'OK2') + self.assertRaises(ConfigurationError, config.resource, + 'a:foo.pt', 'a:foo/') - def test_notfound(self): - from repoze.bfg.interfaces import INotFoundView + def test_resource_success(self): config = self._makeOne() - view = lambda *arg: 'OK' - config.notfound(view) - request = self._makeRequest(config) - view = config.reg.getUtility(INotFoundView) - result = view(None, request) - self.assertEqual(result, 'OK') + override = DummyUnderOverride() + config.resource( + 'repoze.bfg.tests.fixtureapp:templates/foo.pt', + 'repoze.bfg.tests.fixtureapp.subpackage:templates/bar.pt', + _override=override) + from repoze.bfg.tests import fixtureapp + from repoze.bfg.tests.fixtureapp import subpackage + self.assertEqual(override.package, fixtureapp) + self.assertEqual(override.path, 'templates/foo.pt') + self.assertEqual(override.override_package, subpackage) + self.assertEqual(override.override_prefix, 'templates/bar.pt') - def test_forbidden(self): - from repoze.bfg.interfaces import IForbiddenView - config = self._makeOne() - view = lambda *arg: 'OK' - config.forbidden(view) - request = self._makeRequest(config) - view = config.reg.getUtility(IForbiddenView) - result = view(None, request) - self.assertEqual(result, 'OK') +class Test__map_view(unittest.TestCase): + def setUp(self): + from repoze.bfg.registry import Registry + self.registry = Registry() - def test_authentication_policy(self): - from repoze.bfg.interfaces import IAuthenticationPolicy - config = self._makeOne() - policy = object() - config.authentication_policy(policy) - self.assertEqual(config.reg.getUtility(IAuthenticationPolicy), policy) + def tearDown(self): + del self.registry + + def _registerRenderer(self, name='.txt'): + from repoze.bfg.interfaces import IRendererFactory + from repoze.bfg.interfaces import ITemplateRenderer + from zope.interface import implements + class Renderer: + implements(ITemplateRenderer) + def __init__(self, path): + self.__class__.path = path + def __call__(self, *arg): + return 'Hello!' + self.registry.registerUtility(Renderer, IRendererFactory, name=name) + return Renderer(name) - def test_authorization_policy(self): - from repoze.bfg.interfaces import IAuthorizationPolicy - config = self._makeOne() - policy = object() - config.authorization_policy(policy) - self.assertEqual(config.reg.getUtility(IAuthorizationPolicy), policy) + def _makeRequest(self): + request = DummyRequest() + request.registry = self.registry + return request - def test_derive_view_as_function_context_and_request(self): + def _callFUT(self, *arg, **kw): + from repoze.bfg.configuration import _map_view + return _map_view(*arg, **kw) + + def test__map_view_as_function_context_and_request(self): def view(context, request): return 'OK' - config = self._makeOne() - result = config.derive_view(view) + result = self._callFUT(self.registry, view) self.failUnless(result is view) - self.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(view(None, None), 'OK') + self.assertEqual(result(None, None), 'OK') + + def test__map_view_as_function_with_attr(self): + def view(context, request): + """ """ + result = self._callFUT(self.registry, view, attr='__name__') + self.failIf(result is view) + self.assertRaises(TypeError, result, None, None) + + def test__map_view_as_function_with_attr_and_renderer(self): + self._registerRenderer() + view = lambda *arg: 'OK' + result = self._callFUT(self.registry, view, attr='__name__', + renderer_name='fixtures/minimal.txt') + self.failIf(result is view) + self.assertRaises(TypeError, result, None, None) - def test_derive_view_as_function_requestonly(self): + def test__map_view_as_function_requestonly(self): def view(request): return 'OK' - config = self._makeOne() - result = config.derive_view(view) + result = self._callFUT(self.registry, view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test_derive_view_as_newstyle_class_context_and_request(self): + def test__map_view_as_function_requestonly_with_attr(self): + def view(request): + """ """ + result = self._callFUT(self.registry, 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__map_view_as_newstyle_class_context_and_request(self): class view(object): def __init__(self, context, request): pass def __call__(self): return 'OK' - config = self._makeOne() - result = config.derive_view(view) + result = self._callFUT(self.registry, view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - - def test_derive_view_as_newstyle_class_requestonly(self): + + def test__map_view_as_newstyle_class_context_and_request_with_attr(self): class view(object): def __init__(self, context, request): pass - def __call__(self): + def index(self): return 'OK' - config = self._makeOne() - result = config.derive_view(view) + result = self._callFUT(self.registry, 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.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test_derive_view_as_oldstyle_class_context_and_request(self): - class view: + def test__map_view_as_newstyle_class_context_and_request_attr_and_renderer( + self): + renderer = self._registerRenderer() + class view(object): def __init__(self, context, request): pass - def __call__(self): - return 'OK' - config = self._makeOne() - result = config.derive_view(view) + def index(self): + return {'a':'1'} + result = self._callFUT( + self.registry, + view, attr='index', + renderer = renderer) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(result(None, None), 'OK') + request = self._makeRequest() + self.assertEqual(result(None, request).body, 'Hello!') - def test_derive_view_as_oldstyle_class_requestonly(self): - class view: - def __init__(self, context, request): + def test__map_view_as_newstyle_class_requestonly(self): + class view(object): + def __init__(self, request): pass def __call__(self): return 'OK' - config = self._makeOne() - result = config.derive_view(view) + result = self._callFUT(self.registry, view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test_derive_view_as_instance_context_and_request(self): - class View: - def __call__(self, context, request): - return 'OK' - view = View() - config = self._makeOne() - result = config.derive_view(view) - self.failUnless(result is view) - self.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(result(None, None), 'OK') - - def test_derive_view_as_instance_requestonly(self): - class View: - def __call__(self, request): + def test__map_view_as_newstyle_class_requestonly_with_attr(self): + class view(object): + def __init__(self, request): + pass + def index(self): return 'OK' - view = View() - config = self._makeOne() - result = config.derive_view(view) + result = self._callFUT(self.registry, 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.failIf(hasattr(result, '__call_permissive__')) + self.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_derive_view_with_debug_authorization_no_authpol(self): - view = lambda *arg: 'OK' - config = self._makeOne() - self._registerSettings(config, - debug_authorization=True, reload_templates=True) - logger = self._registerLogger(config) - result = config.derive_view(view, permission='view') + def test__map_view_as_newstyle_class_requestonly_attr_and_renderer(self): + renderer = self._registerRenderer() + class view(object): + def __init__(self, request): + pass + def index(self): + return {'a':'1'} + result = self._callFUT( + self.registry, + view, attr='index', + renderer = renderer) + self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) - request = self._makeRequest(config) - request.view_name = 'view_name' - request.url = 'url' - self.assertEqual(result(None, request), 'OK') - self.assertEqual(len(logger.messages), 1) - self.assertEqual(logger.messages[0], - "debug_authorization of url url (view name " - "'view_name' against context None): Allowed " - "(no authorization policy in use)") + request = self._makeRequest() + self.assertEqual(result(None, request).body, 'Hello!') - def test_derive_view_with_debug_authorization_no_permission(self): - view = lambda *arg: 'OK' - config = self._makeOne() - self._registerSettings(config, - debug_authorization=True, reload_templates=True) - self._registerSecurityPolicy(config, True) - logger = self._registerLogger(config) - result = config.derive_view(view) + def test__map_view_as_oldstyle_class_context_and_request(self): + class view: + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = self._callFUT(self.registry, view) + self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) - request = self._makeRequest(config) - request.view_name = 'view_name' - request.url = 'url' - self.assertEqual(result(None, request), 'OK') - self.assertEqual(len(logger.messages), 1) - self.assertEqual(logger.messages[0], - "debug_authorization of url url (view name " - "'view_name' against context None): Allowed (" - "no permission registered)") + self.assertEqual(result(None, None), 'OK') - def test_derive_view_debug_authorization_permission_authpol_permitted(self): - view = lambda *arg: 'OK' - config = self._makeOne() - self._registerSettings(config, debug_authorization=True, - reload_templates=True) - logger = self._registerLogger(config) - self._registerSecurityPolicy(config, True) - result = config.derive_view(view, permission='view') + def test__map_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(self.registry, 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.__call_permissive__, view) - request = self._makeRequest(config) - request.view_name = 'view_name' - request.url = 'url' - self.assertEqual(result(None, request), 'OK') - self.assertEqual(len(logger.messages), 1) - self.assertEqual(logger.messages[0], - "debug_authorization of url url (view name " - "'view_name' against context None): True") - - def test_derive_view_debug_authorization_permission_authpol_denied(self): - from repoze.bfg.exceptions import Forbidden - view = lambda *arg: 'OK' - config = self._makeOne() - self._registerSettings(config, - debug_authorization=True, reload_templates=True) - logger = self._registerLogger(config) - self._registerSecurityPolicy(config, False) - result = config.derive_view(view, permission='view') + self.assertEqual(result(None, None), 'OK') + + def test__map_view_as_oldstyle_cls_context_request_attr_and_renderer(self): + renderer = self._registerRenderer() + class view: + def __init__(self, context, request): + pass + def index(self): + return {'a':'1'} + result = self._callFUT( + self.registry, + view, attr='index', + renderer = renderer) + 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.__call_permissive__, view) - request = self._makeRequest(config) - request.view_name = 'view_name' - request.url = 'url' - self.assertRaises(Forbidden, result, None, request) - self.assertEqual(len(logger.messages), 1) - self.assertEqual(logger.messages[0], - "debug_authorization of url url (view name " - "'view_name' against context None): False") + request = self._makeRequest() + self.assertEqual(result(None, request).body, 'Hello!') - def test_derive_view_debug_authorization_permission_authpol_denied2(self): - view = lambda *arg: 'OK' - config = self._makeOne() - self._registerSettings(config, - debug_authorization=True, reload_templates=True) - logger = self._registerLogger(config) - self._registerSecurityPolicy(config, False) - result = config.derive_view(view, permission='view') + def test__map_view_as_oldstyle_class_requestonly(self): + class view: + def __init__(self, request): + pass + def __call__(self): + return 'OK' + result = self._callFUT(self.registry, view) + self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - request = self._makeRequest(config) - request.view_name = 'view_name' - request.url = 'url' - permitted = result.__permitted__(None, None) - self.assertEqual(permitted, False) + self.assertEqual(result(None, None), 'OK') - def test_derive_view_with_predicates_all(self): - view = lambda *arg: 'OK' - predicates = [] - def predicate1(context, request): - predicates.append(True) - return True - def predicate2(context, request): - predicates.append(True) - return True - config = self._makeOne() - result = config.derive_view(view, predicates=[predicate1, predicate2]) - request = self._makeRequest(config) - request.method = 'POST' - next = result(None, None) - self.assertEqual(next, 'OK') - self.assertEqual(predicates, [True, True]) + def test__map_view_as_oldstyle_class_requestonly_with_attr(self): + class view: + def __init__(self, request): + pass + def index(self): + return 'OK' + result = self._callFUT(self.registry, 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_derive_view_with_predicates_checker(self): - view = lambda *arg: 'OK' - predicates = [] - def predicate1(context, request): - predicates.append(True) - return True - def predicate2(context, request): - predicates.append(True) - return True - config = self._makeOne() - result = config.derive_view(view, predicates=[predicate1, predicate2]) - request = self._makeRequest(config) - request.method = 'POST' - next = result.__predicated__(None, None) - self.assertEqual(next, True) - self.assertEqual(predicates, [True, True]) + def test__map_view_as_oldstyle_class_requestonly_attr_and_renderer(self): + renderer = self._registerRenderer() + class view: + def __init__(self, request): + pass + def index(self): + return {'a':'1'} + result = self._callFUT( + self.registry, + view, attr='index', + renderer = renderer) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = self._makeRequest() + self.assertEqual(result(None, request).body, 'Hello!') - def test_derive_view_with_predicates_notall(self): - from repoze.bfg.exceptions import NotFound - view = lambda *arg: 'OK' - predicates = [] - def predicate1(context, request): - predicates.append(True) - return True - def predicate2(context, request): - predicates.append(True) - return False - config = self._makeOne() - result = config.derive_view(view, predicates=[predicate1, predicate2]) - request = self._makeRequest(config) - request.method = 'POST' - self.assertRaises(NotFound, result, None, None) - self.assertEqual(predicates, [True, True]) + def test__map_view_as_instance_context_and_request(self): + class View: + def __call__(self, context, request): + return 'OK' + view = View() + result = self._callFUT(self.registry, view) + self.failUnless(result is view) + self.assertEqual(result(None, None), 'OK') + + def test__map_view_as_instance_context_and_request_and_attr(self): + class View: + def index(self, context, request): + return 'OK' + view = View() + result = self._callFUT(self.registry, view, attr='index') + self.failIf(result is view) + self.assertEqual(result(None, None), 'OK') - def test_derive_view_with_wrapper_viewname(self): - from webob import Response - from repoze.bfg.interfaces import IView - inner_response = Response('OK') - def inner_view(context, request): - return inner_response - def outer_view(context, request): - self.assertEqual(request.wrapped_response, inner_response) - self.assertEqual(request.wrapped_body, inner_response.body) - self.assertEqual(request.wrapped_view, inner_view) - return Response('outer ' + request.wrapped_body) - config = self._makeOne() - config.reg.registerAdapter(outer_view, (None, None), IView, 'owrap') - result = config.derive_view(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__) - request = self._makeRequest(config) - request.registry = config.reg - response = result(None, request) - self.assertEqual(response.body, 'outer OK') + def test__map_view_as_instance_context_and_request_attr_and_renderer(self): + renderer = self._registerRenderer() + class View: + def index(self, context, request): + return {'a':'1'} + view = View() + result = self._callFUT( + self.registry, + view, attr='index', + renderer=renderer) + self.failIf(result is view) + request = self._makeRequest() + self.assertEqual(result(None, request).body, 'Hello!') - def test_derive_view_with_wrapper_viewname_notfound(self): - from webob import Response - inner_response = Response('OK') - def inner_view(context, request): - return inner_response - config = self._makeOne() - request = self._makeRequest(config) - request.registry = config.reg - wrapped = config.derive_view( - inner_view, viewname='inner', wrapper_viewname='owrap') - result = self.assertRaises(ValueError, wrapped, None, request) + def test__map_view_as_instance_requestonly(self): + class View: + def __call__(self, request): + return 'OK' + view = View() + result = self._callFUT(self.registry, view) + 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_resource_samename(self): - from zope.configuration.exceptions import ConfigurationError - config = self._makeOne() - self.assertRaises(ConfigurationError, config.resource, 'a', 'a') + def test__map_view_as_instance_requestonly_with_attr(self): + class View: + def index(self, request): + return 'OK' + view = View() + result = self._callFUT(self.registry, 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_resource_override_directory_with_file(self): - from zope.configuration.exceptions import ConfigurationError - config = self._makeOne() - self.assertRaises(ConfigurationError, config.resource, - 'a:foo/', 'a:foo.pt') + def test__map_view_as_instance_requestonly_with_attr_and_renderer(self): + renderer = self._registerRenderer() + class View: + def index(self, request): + return {'a':'1'} + view = View() + result = self._callFUT( + self.registry, + view, attr='index', + renderer = renderer) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.failUnless('instance' in result.__name__) + request = self._makeRequest() + self.assertEqual(result(None, request).body, 'Hello!') - def test_resource_override_file_with_directory(self): - from zope.configuration.exceptions import ConfigurationError - config = self._makeOne() - self.assertRaises(ConfigurationError, config.resource, - 'a:foo.pt', 'a:foo/') + def test__map_view_rendereronly(self): + renderer = self._registerRenderer() + def view(context, request): + return {'a':'1'} + result = self._callFUT( + self.registry, + view, + renderer=renderer) + 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_resource_success(self): - config = self._makeOne() - override = DummyUnderOverride() - config.resource( - 'repoze.bfg.tests.fixtureapp:templates/foo.pt', - 'repoze.bfg.tests.fixtureapp.subpackage:templates/bar.pt', - _override=override) - from repoze.bfg.tests import fixtureapp - from repoze.bfg.tests.fixtureapp import subpackage - self.assertEqual(override.package, fixtureapp) - self.assertEqual(override.path, 'templates/foo.pt') - self.assertEqual(override.override_package, subpackage) - self.assertEqual(override.override_prefix, 'templates/bar.pt') class TestBFGViewGrokker(unittest.TestCase): def setUp(self): diff --git a/repoze/bfg/zcml.py b/repoze/bfg/zcml.py index f801c62ac..77ac4c8fa 100644 --- a/repoze/bfg/zcml.py +++ b/repoze/bfg/zcml.py @@ -24,6 +24,7 @@ from repoze.bfg.authentication import RepozeWho1AuthenticationPolicy from repoze.bfg.authentication import RemoteUserAuthenticationPolicy from repoze.bfg.authentication import AuthTktAuthenticationPolicy from repoze.bfg.authorization import ACLAuthorizationPolicy +from repoze.bfg.configuration import Configurator from repoze.bfg.request import route_request_iface from repoze.bfg.threadlocal import get_current_registry from repoze.bfg.static import StaticRootFactory @@ -163,7 +164,7 @@ def view( renderer = _context.path(renderer) def register(): - config = get_configurator(reg) + config = Configurator(reg) config.view( permission=permission, for_=for_, view=view, name=name, request_type=request_type, route_name=route_name, @@ -242,7 +243,7 @@ def route(_context, name, path, view=None, view_for=None, view_renderer = _context.path(view_renderer) def register(): - config = get_configurator(reg) + config = Configurator(reg) config.route( name, path, @@ -320,7 +321,7 @@ class SystemViewHandler(object): def register(iface=self.iface): reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) config.system_view(iface, view=view, attr=attr, renderer=renderer, wrapper=wrapper, _info=_context.info) @@ -348,7 +349,7 @@ class IResourceDirective(Interface): def resource(_context, to_override, override_with): reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) _context.action( discriminator = None, @@ -368,7 +369,7 @@ def repozewho1authenticationpolicy(_context, identifier_name='auth_tkt', # authentication policies must be registered eagerly so they can # be found by the view registration machinery reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) config.authentication_policy(policy, _info=_context.info) _context.action(discriminator=IAuthenticationPolicy) @@ -384,7 +385,7 @@ def remoteuserauthenticationpolicy(_context, environ_key='REMOTE_USER', # authentication policies must be registered eagerly so they can # be found by the view registration machinery reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) config.authentication_policy(policy, _info=_context.info) _context.action(discriminator=IAuthenticationPolicy) @@ -422,7 +423,7 @@ def authtktauthenticationpolicy(_context, # authentication policies must be registered eagerly so they can # be found by the view registration machinery reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) config.authentication_policy(policy, _info=_context.info) _context.action(discriminator=IAuthenticationPolicy) @@ -434,7 +435,7 @@ def aclauthorizationpolicy(_context): # authorization policies must be registered eagerly so they can be # found by the view registration machinery reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) config.authorization_policy(policy, _info=_context.info) _context.action(discriminator=IAuthorizationPolicy) @@ -451,7 +452,7 @@ def renderer(_context, factory, name=''): # renderer factories must be registered eagerly so they can be # found by the view machinery reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) config.renderer(factory, name, _info=_context.info) _context.action(discriminator=(IRendererFactory, name)) @@ -479,7 +480,7 @@ def static(_context, name, path, cache_max_age=3600): """ abspath = _context.path(path) reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) _context.action( discriminator = ('route', name, False, None, None, None, None, None), @@ -504,7 +505,7 @@ def scan(_context, package, martian=martian): # martian overrideable only for unit tests def register(): reg = get_current_registry() - config = get_configurator(reg) + config = Configurator(reg) config.scan(package, _info=_context.info, martian=martian) _context.action(discriminator=None, callable=register) @@ -524,16 +525,3 @@ def zcml_configure(name, package): file_configure = zcml_configure # backwards compat (>0.8.1) -def get_configurator(reg): - # dont create a new configurator instance unless necessary, as - # frames will point to each configurator instance via closures - # when some configuration methods (such as config.view) are - # called. - from repoze.bfg.configuration import Configurator - try: - config = reg.get('bfg_configurator') - except: - config = None - if config is None: - config = Configurator(reg) - return config -- cgit v1.2.3