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/tests/test_configuration.py | 1268 ++++++++++++++++---------------- 1 file changed, 636 insertions(+), 632 deletions(-) (limited to 'repoze/bfg/tests') 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): -- cgit v1.2.3