From de821203ffe585cb63b19bcfc238503994f15725 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Thu, 19 Nov 2009 00:34:21 +0000 Subject: Checkpoint: move most zcml route and view directive tests to test_configuration. --- repoze/bfg/tests/test_configuration.py | 885 ++++++++++- repoze/bfg/tests/test_request.py | 1 + repoze/bfg/tests/test_zcml.py | 2641 ++++---------------------------- 3 files changed, 1148 insertions(+), 2379 deletions(-) (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py index 5449e0933..1916fe11d 100644 --- a/repoze/bfg/tests/test_configuration.py +++ b/repoze/bfg/tests/test_configuration.py @@ -17,10 +17,779 @@ class ConfiguratorTests(unittest.TestCase): class Renderer: implements(ITemplateRenderer) def __init__(self, path): - pass + self.__class__.path = path def __call__(self, *arg): return 'Hello!' config.reg.registerUtility(Renderer, IRendererFactory, name=name) + return Renderer + + def _getViewCallable(self, config, ctx_iface=None, request_iface=None, + name=''): + from zope.interface import Interface + from repoze.bfg.interfaces import IRequest + from repoze.bfg.interfaces import IView + if ctx_iface is None: + ctx_iface = Interface + if request_iface is None: + request_iface = IRequest + return config.reg.adapters.lookup( + (ctx_iface, request_iface), IView, name=name, + default=None) + + def _callDefaultConfiguration(self, *arg, **kw): + inst = self._makeOne() + inst.default_configuration(*arg, **kw) + return inst.reg + + def _getRouteRequestIface(self, config, name): + from repoze.bfg.interfaces import IRouteRequest + iface = config.reg.getUtility(IRouteRequest, name) + return iface + + def _assertNotFound(self, wrapper, *arg): + from repoze.bfg.exceptions import NotFound + self.assertRaises(NotFound, wrapper, *arg) + + def test_view_view_callable_None_no_renderer(self): + from zope.configuration.exceptions import ConfigurationError + config = self._makeOne() + self.assertRaises(ConfigurationError, config.view) + + def test_view_with_request_type_and_route_name(self): + from zope.configuration.exceptions import ConfigurationError + config = self._makeOne() + view = lambda *arg: 'OK' + self.assertRaises(ConfigurationError, config.view, view, '', None, + None, True, True) + + def test_view_view_callable_None_with_renderer(self): + config = self._makeOne() + self._registerRenderer(config, name='dummy') + config.view(renderer='dummy') + view = self._getViewCallable(config) + self.failUnless('Hello!' in view(None, None).body) + + def test_wrapped_view_is_decorated(self): + def view(request): # request-only wrapper + """ """ + config = self._makeOne() + config.view(view=view) + wrapper = self._getViewCallable(config) + self.assertEqual(wrapper.__module__, view.__module__) + self.assertEqual(wrapper.__name__, view.__name__) + self.assertEqual(wrapper.__doc__, view.__doc__) + + def test_view_with_function_callable(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view) + wrapper = self._getViewCallable(config) + result = wrapper(None, None) + self.assertEqual(result, 'OK') + + def test_view_with_function_callable_requestonly(self): + def view(request): + return 'OK' + config = self._makeOne() + config.view(view=view) + wrapper = self._getViewCallable(config) + result = wrapper(None, None) + self.assertEqual(result, 'OK') + + def test_view_as_instance(self): + class AView: + def __call__(self, context, request): + """ """ + return 'OK' + view = AView() + config = self._makeOne() + config.view(view=view) + wrapper = self._getViewCallable(config) + result = wrapper(None, None) + self.assertEqual(result, 'OK') + + def test_view_as_instance_requestonly(self): + class AView: + def __call__(self, request): + """ """ + return 'OK' + view = AView() + config = self._makeOne() + config.view(view=view) + wrapper = self._getViewCallable(config) + result = wrapper(None, None) + self.assertEqual(result, 'OK') + + def test_view_as_oldstyle_class(self): + class view: + def __init__(self, context, request): + self.context = context + self.request = request + + def __call__(self): + return 'OK' + config = self._makeOne() + config.view(view=view) + wrapper = self._getViewCallable(config) + result = wrapper(None, None) + self.assertEqual(result, 'OK') + + def test_view_as_oldstyle_class_requestonly(self): + class view: + def __init__(self, request): + self.request = request + + def __call__(self): + return 'OK' + config = self._makeOne() + config.view(view=view) + wrapper = self._getViewCallable(config) + result = wrapper(None, None) + self.assertEqual(result, 'OK') + + def test_view_for_as_class(self): + from zope.interface import implementedBy + view = lambda *arg: 'OK' + class Foo: + pass + config = self._makeOne() + config.view(for_=Foo, view=view) + foo = implementedBy(Foo) + wrapper = self._getViewCallable(config, foo) + self.assertEqual(wrapper, view) + + def test_view_for_as_iface(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(for_=IDummy, view=view) + wrapper = self._getViewCallable(config, IDummy) + self.assertEqual(wrapper, view) + + def test_view_register_secured_view(self): + from zope.component import Interface + from repoze.bfg.interfaces import IRequest + from repoze.bfg.interfaces import ISecuredView + view = lambda *arg: 'OK' + view.__call_permissive__ = view + config = self._makeOne() + config.view(view=view) + wrapper = config.reg.adapters.lookup( + (Interface, IRequest), ISecuredView, name='', default=None) + self.assertEqual(wrapper, view) + + def test_view_multiview_replaces_existing_view(self): + from zope.component import Interface + from repoze.bfg.interfaces import IRequest + from repoze.bfg.interfaces import IView + from repoze.bfg.interfaces import IMultiView + view = lambda *arg: 'OK' + config = self._makeOne() + config.reg.registerAdapter(view, (Interface, IRequest), IView, name='') + config.view(view=view) + wrapper = self._getViewCallable(config) + self.failUnless(IMultiView.providedBy(wrapper)) + self.assertEqual(wrapper(None, None), 'OK') + + def test_view_multiview_replaces_multiview(self): + from zope.component import Interface + from zope.interface import implements + from repoze.bfg.interfaces import IRequest + from repoze.bfg.interfaces import IMultiView + class DummyMultiView: + implements(IMultiView) + def __init__(self): + self.views = [] + self.name = 'name' + def add(self, view, score): + self.views.append(view) + def __call__(self, context, request): + return 'OK1' + def __permitted__(self, context, request): + """ """ + view = DummyMultiView() + config = self._makeOne() + config.reg.registerAdapter(view, (Interface, IRequest), + IMultiView, name='') + view2 = lambda *arg: 'OK2' + config.view(view=view2) + wrapper = self._getViewCallable(config) + self.failUnless(IMultiView.providedBy(wrapper)) + self.assertEqual(wrapper.views, [view2]) + self.assertEqual(wrapper(None, None), 'OK1') + + def test_view_multiview_call_ordering(self): + from zope.interface import directlyProvides + def view1(context, request): return 'view1' + def view2(context, request): return 'view2' + def view3(context, request): return 'view3' + def view4(context, request): return 'view4' + def view5(context, request): return 'view5' + def view6(context, request): return 'view6' + def view7(context, request): return 'view7' + def view8(context, request): return 'view8' + config = self._makeOne() + config.view(view=view1) + config.view(view=view2, request_method='POST') + config.view(view=view3,request_param='param') + config.view(view=view4, containment=IDummy) + config.view(view=view5, request_method='POST', request_param='param') + config.view(view=view6, request_method='POST', containment=IDummy) + config.view(view=view7, request_param='param', containment=IDummy) + config.view(view=view8, request_method='POST', request_param='param', + containment=IDummy) + + wrapper = self._getViewCallable(config) + + ctx = DummyContext() + request = DummyRequest() + request.method = 'GET' + request.params = {} + self.assertEqual(wrapper(ctx, request), 'view1') + + ctx = DummyContext() + request = DummyRequest() + request.params = {} + request.method = 'POST' + self.assertEqual(wrapper(ctx, request), 'view2') + + ctx = DummyContext() + request = DummyRequest() + request.params = {'param':'1'} + request.method = 'GET' + self.assertEqual(wrapper(ctx, request), 'view3') + + ctx = DummyContext() + directlyProvides(ctx, IDummy) + request = DummyRequest() + request.method = 'GET' + request.params = {} + self.assertEqual(wrapper(ctx, request), 'view4') + + ctx = DummyContext() + request = DummyRequest() + request.method = 'POST' + request.params = {'param':'1'} + self.assertEqual(wrapper(ctx, request), 'view5') + + ctx = DummyContext() + directlyProvides(ctx, IDummy) + request = DummyRequest() + request.params = {} + request.method = 'POST' + self.assertEqual(wrapper(ctx, request), 'view6') + + ctx = DummyContext() + directlyProvides(ctx, IDummy) + request = DummyRequest() + request.method = 'GET' + request.params = {'param':'1'} + self.assertEqual(wrapper(ctx, request), 'view7') + + ctx = DummyContext() + directlyProvides(ctx, IDummy) + request = DummyRequest() + request.method = 'POST' + request.params = {'param':'1'} + self.assertEqual(wrapper(ctx, request), 'view8') + + def test_view_with_relative_template_renderer(self): + class view(object): + def __init__(self, context, request): + self.request = request + self.context = context + + def __call__(self): + return {'a':'1'} + config = self._makeOne() + renderer = self._registerRenderer(config) + fixture = 'fixtures/minimal.txt' + config.view(view=view, renderer=fixture) + wrapper = self._getViewCallable(config) + request = DummyRequest() + result = wrapper(None, request) + self.assertEqual(result.body, 'Hello!') + self.assertEqual(renderer.path, 'fixtures/minimal.txt') + + def test_view_with_relative_template_renderer_no_callable(self): + config = self._makeOne() + renderer = self._registerRenderer(config) + fixture = 'fixtures/minimal.txt' + config.view(view=None, renderer=fixture) + wrapper = self._getViewCallable(config) + request = DummyRequest() + result = wrapper(None, request) + self.assertEqual(result.body, 'Hello!') + self.assertEqual(renderer.path, 'fixtures/minimal.txt') + + def test_view_with_request_type_as_iface(self): + def view(context, request): + return 'OK' + config = self._makeOne() + config.view(request_type=IDummy, view=view) + wrapper = self._getViewCallable(config, None, IDummy) + result = wrapper(None, None) + self.assertEqual(result, 'OK') + + def test_view_with_request_type_as_noniface(self): + from zope.interface import providedBy + def view(context, request): + return 'OK' + config = self._makeOne() + config.view(request_type=object, view=view) + request_iface = providedBy(object) + wrapper = self._getViewCallable(config, None, request_iface) + result = wrapper(None, None) + self.assertEqual(result, 'OK') + + def test_view_with_route_name(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, route_name='foo') + request_type = self._getRouteRequestIface(config, 'foo') + wrapper = self._getViewCallable(config, None, request_type) + self.assertEqual(wrapper(None, None), 'OK') + + def test_view_with_request_method_true(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, request_method='POST') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.method = 'POST' + self.assertEqual(wrapper(None, request), 'OK') + + def test_view_with_request_method_false(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, request_method='POST') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.method = 'GET' + self._assertNotFound(wrapper, None, request) + + def test_view_with_request_param_noval_true(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, request_param='abc') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.params = {'abc':''} + self.assertEqual(wrapper(None, request), 'OK') + + def test_view_with_request_param_noval_false(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, request_param='abc') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.params = {} + self._assertNotFound(wrapper, None, request) + + def test_view_with_request_param_val_true(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, request_param='abc=123') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.params = {'abc':'123'} + self.assertEqual(wrapper(None, request), 'OK') + + def test_view_with_request_param_val_false(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, request_param='abc=123') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.params = {'abc':''} + self._assertNotFound(wrapper, None, request) + + def test_view_with_xhr_true(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, xhr=True) + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.is_xhr = True + self.assertEqual(wrapper(None, request), 'OK') + + def test_view_with_xhr_false(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, xhr=True) + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.is_xhr = False + self._assertNotFound(wrapper, None, request) + + def test_view_with_header_badregex(self): + from zope.configuration.exceptions import ConfigurationError + view = lambda *arg: 'OK' + config = self._makeOne() + self.assertRaises(ConfigurationError, + config.view, view=view, header='Host:a\\') + + def test_view_with_header_noval_match(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, header='Host') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.headers = {'Host':'whatever'} + self.assertEqual(wrapper(None, request), 'OK') + + def test_view_with_header_noval_nomatch(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, header='Host') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.headers = {'NotHost':'whatever'} + self._assertNotFound(wrapper, None, request) + + def test_view_with_header_val_match(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, header=r'Host:\d') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.headers = {'Host':'1'} + self.assertEqual(wrapper(None, request), 'OK') + + def test_view_with_header_val_nomatch(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, header=r'Host:\d') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.headers = {'Host':'abc'} + self._assertNotFound(wrapper, None, request) + + def test_view_with_accept_match(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, accept='text/xml') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.accept = ['text/xml'] + self.assertEqual(wrapper(None, request), 'OK') + + def test_view_with_accept_nomatch(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, accept='text/xml') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.accept = ['text/html'] + self._assertNotFound(wrapper, None, request) + + def test_view_with_containment_true(self): + from zope.interface import directlyProvides + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, containment=IDummy) + wrapper = self._getViewCallable(config) + request = DummyRequest() + context = DummyContext() + directlyProvides(context, IDummy) + self.assertEqual(wrapper(context, None), 'OK') + + def test_view_with_containment_false(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, containment=IDummy) + wrapper = self._getViewCallable(config) + request = DummyRequest() + context = DummyContext() + self._assertNotFound(wrapper, context, None) + + def test_view_with_path_info_badregex(self): + from zope.configuration.exceptions import ConfigurationError + view = lambda *arg: 'OK' + config = self._makeOne() + self.assertRaises(ConfigurationError, + config.view, view=view, path_info='\\') + + def test_with_path_info_match(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, path_info='/foo') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.path_info = '/foo' + self.assertEqual(wrapper(None, request), 'OK') + + def test_with_path_info_nomatch(self): + view = lambda *arg: 'OK' + config = self._makeOne() + config.view(view=view, path_info='/foo') + wrapper = self._getViewCallable(config) + request = DummyRequest() + request.path_info = '/' + self._assertNotFound(wrapper, None, request) + + def _assertRoute(self, config, name, path, num_predicates=0): + from repoze.bfg.interfaces import IRoutesMapper + mapper = config.reg.getUtility(IRoutesMapper) + routes = mapper.get_routes() + route = routes[0] + self.assertEqual(len(routes), 1) + self.assertEqual(route.name, name) + self.assertEqual(route.path, path) + self.assertEqual(len(routes[0].predicates), num_predicates) + return route + + def test_route_defaults(self): + config = self._makeOne() + config.route('name', 'path') + self._assertRoute(config, 'name', 'path') + + def test_route_with_xhr(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', xhr=True) + request_type = self._getRouteRequestIface(config, 'name') + route = self._assertRoute(config, 'name', 'path', 1) + predicate = route.predicates[0] + request = DummyRequest() + request.is_xhr = True + self.assertEqual(predicate(None, request), True) + request = DummyRequest() + request.is_xhr = False + self.assertEqual(predicate(None, request), False) + + def test_route_with_request_method(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', request_method='GET') + request_type = self._getRouteRequestIface(config, 'name') + route = self._assertRoute(config, 'name', 'path', 1) + predicate = route.predicates[0] + request = DummyRequest() + request.method = 'GET' + self.assertEqual(predicate(None, request), True) + request = DummyRequest() + request.method = 'POST' + self.assertEqual(predicate(None, request), False) + + def test_route_with_path_info(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', path_info='/foo') + request_type = self._getRouteRequestIface(config, 'name') + route = self._assertRoute(config, 'name', 'path', 1) + predicate = route.predicates[0] + request = DummyRequest() + request.path_info = '/foo' + self.assertEqual(predicate(None, request), True) + request = DummyRequest() + request.path_info = '/' + self.assertEqual(predicate(None, request), False) + + def test_route_with_request_param(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', request_param='abc') + request_type = self._getRouteRequestIface(config, 'name') + route = self._assertRoute(config, 'name', 'path', 1) + predicate = route.predicates[0] + request = DummyRequest() + request.params = {'abc':'123'} + self.assertEqual(predicate(None, request), True) + request = DummyRequest() + request.params = {} + self.assertEqual(predicate(None, request), False) + + def test_route_with_header(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', header='Host') + request_type = self._getRouteRequestIface(config, 'name') + route = self._assertRoute(config, 'name', 'path', 1) + predicate = route.predicates[0] + request = DummyRequest() + request.headers = {'Host':'example.com'} + self.assertEqual(predicate(None, request), True) + request = DummyRequest() + request.headers = {} + self.assertEqual(predicate(None, request), False) + + def test_route_with_accept(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', accept='text/xml') + request_type = self._getRouteRequestIface(config, 'name') + route = self._assertRoute(config, 'name', 'path', 1) + predicate = route.predicates[0] + request = DummyRequest() + request.accept = ['text/xml'] + self.assertEqual(predicate(None, request), True) + request = DummyRequest() + request.accept = ['text/html'] + self.assertEqual(predicate(None, request), False) + + def test_route_with_view(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view) + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + self.assertEqual(wrapper(None, None), 'OK') + self._assertRoute(config, 'name', 'path') + + def test_route_with_view_for(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, view_for=IDummy) + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, IDummy, request_type) + self.assertEqual(wrapper(None, None), 'OK') + self._assertRoute(config, 'name', 'path') + wrapper = self._getViewCallable(config, IOther, request_type) + self.assertEqual(wrapper, None) + + def test_route_with_view_for_alias(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, for_=IDummy) + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, IDummy, request_type) + self.assertEqual(wrapper(None, None), 'OK') + self._assertRoute(config, 'name', 'path') + wrapper = self._getViewCallable(config, IOther, request_type) + self.assertEqual(wrapper, None) + + def test_route_with_view_request_method(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, view_request_method='GET') + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + request = DummyRequest() + request.method = 'GET' + self.assertEqual(wrapper(None, request), 'OK') + request = DummyRequest() + request.method = 'POST' + self._assertNotFound(wrapper, None, request) + + def test_route_with_view_header(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, view_header='Host') + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + request = DummyRequest() + request.headers = {'Host':'abc'} + self.assertEqual(wrapper(None, request), 'OK') + request = DummyRequest() + request.headers = {} + self._assertNotFound(wrapper, None, request) + + def test_route_with_view_xhr(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, view_xhr=True) + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + request = DummyRequest() + request.is_xhr = True + self.assertEqual(wrapper(None, request), 'OK') + request = DummyRequest() + request.is_xhr = False + self._assertNotFound(wrapper, None, request) + + def test_route_with_view_path_info(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, view_path_info='/foo') + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + request = DummyRequest() + request.path_info = '/foo' + self.assertEqual(wrapper(None, request), 'OK') + request = DummyRequest() + request.path_info = '/' + self._assertNotFound(wrapper, None, request) + + def test_route_with_view_accept(self): + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, view_accept='text/xml') + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + request = DummyRequest() + request.accept = ['text/xml'] + self.assertEqual(wrapper(None, request), 'OK') + request = DummyRequest() + request.accept = ['text/html'] + self._assertNotFound(wrapper, None, request) + + def test_route_with_view_containment(self): + from zope.interface import directlyProvides + config = self._makeOne() + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, view_containment=IDummy) + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + context = DummyContext() + directlyProvides(context, IDummy) + self.assertEqual(wrapper(context, None), 'OK') + self._assertNotFound(wrapper, None, None) + + def test_route_with_view_renderer(self): + config = self._makeOne() + self._registerRenderer(config) + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, + view_renderer='fixtures/minimal.txt') + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + self.assertEqual(wrapper(None, None).body, 'Hello!') + + def test_route_with_view_renderer_alias(self): + config = self._makeOne() + self._registerRenderer(config) + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, + renderer='fixtures/minimal.txt') + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + self.assertEqual(wrapper(None, None).body, 'Hello!') + + def test_route_with_view_permission(self): + from repoze.bfg.interfaces import IAuthenticationPolicy + from repoze.bfg.interfaces import IAuthorizationPolicy + config = self._makeOne() + policy = lambda *arg: None + config.reg.registerUtility(policy, IAuthenticationPolicy) + config.reg.registerUtility(policy, IAuthorizationPolicy) + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, view_permission='edit') + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + self.failUnless(hasattr(wrapper, '__call_permissive__')) + + def test_route_with_view_permission_alias(self): + from repoze.bfg.interfaces import IAuthenticationPolicy + from repoze.bfg.interfaces import IAuthorizationPolicy + config = self._makeOne() + policy = lambda *arg: None + config.reg.registerUtility(policy, IAuthenticationPolicy) + config.reg.registerUtility(policy, IAuthorizationPolicy) + view = lambda *arg: 'OK' + config.route('name', 'path', view=view, permission='edit') + request_type = self._getRouteRequestIface(config, 'name') + wrapper = self._getViewCallable(config, None, request_type) + route = self._assertRoute(config, 'name', 'path') + self.failUnless(hasattr(wrapper, '__call_permissive__')) def test__override_not_yet_registered(self): from repoze.bfg.interfaces import IPackageOverrides @@ -47,83 +816,82 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) self.assertEqual(overrides.package, package) - def test_map_view_as_function_context_and_request(self): + def test__map_view_as_function_context_and_request(self): def view(context, request): return 'OK' config = self._makeOne() - result = config.map_view(view) + result = config._map_view(view) self.failUnless(result is view) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_function_with_attr(self): + def test__map_view_as_function_with_attr(self): def view(context, request): """ """ config = self._makeOne() - result = config.map_view(view, attr='__name__') + result = config._map_view(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): + def test__map_view_as_function_with_attr_and_renderer(self): config = self._makeOne() self._registerRenderer(config) - def view(context, request): - """ """ - result = config.map_view(view, attr='__name__', + 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): + def test__map_view_as_function_requestonly(self): config = self._makeOne() def view(request): return 'OK' - result = config.map_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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_function_requestonly_with_attr(self): + def test__map_view_as_function_requestonly_with_attr(self): config = self._makeOne() def view(request): """ """ - result = config.map_view(view, attr='__name__') + 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) - def test_map_view_as_newstyle_class_context_and_request(self): + def test__map_view_as_newstyle_class_context_and_request(self): config = self._makeOne() class view(object): def __init__(self, context, request): pass def __call__(self): return 'OK' - result = config.map_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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_newstyle_class_context_and_request_with_attr(self): + def test__map_view_as_newstyle_class_context_and_request_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') + 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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_newstyle_class_context_and_request_attr_and_renderer( + def test__map_view_as_newstyle_class_context_and_request_attr_and_renderer( self): config = self._makeOne() self._registerRenderer(config) @@ -132,7 +900,7 @@ class ConfiguratorTests(unittest.TestCase): pass def index(self): return {'a':'1'} - result = config.map_view( + result = config._map_view( view, attr='index', renderer_name='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) @@ -142,35 +910,35 @@ class ConfiguratorTests(unittest.TestCase): request = DummyRequest() self.assertEqual(result(None, request).body, 'Hello!') - def test_map_view_as_newstyle_class_requestonly(self): + def test__map_view_as_newstyle_class_requestonly(self): config = self._makeOne() class view(object): def __init__(self, request): pass def __call__(self): return 'OK' - result = config.map_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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_newstyle_class_requestonly_with_attr(self): + def test__map_view_as_newstyle_class_requestonly_with_attr(self): config = self._makeOne() class view(object): def __init__(self, request): pass def index(self): return 'OK' - result = config.map_view(view, attr='index') + 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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_newstyle_class_requestonly_with_attr_and_renderer( + def test__map_view_as_newstyle_class_requestonly_with_attr_and_renderer( self): config = self._makeOne() self._registerRenderer(config) @@ -179,7 +947,7 @@ class ConfiguratorTests(unittest.TestCase): pass def index(self): return {'a':'1'} - result = config.map_view( + result = config._map_view( view, attr='index', renderer_name='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) @@ -189,35 +957,35 @@ class ConfiguratorTests(unittest.TestCase): request = DummyRequest() self.assertEqual(result(None, request).body, 'Hello!') - def test_map_view_as_oldstyle_class_context_and_request(self): + def test__map_view_as_oldstyle_class_context_and_request(self): config = self._makeOne() class view: def __init__(self, context, request): pass def __call__(self): return 'OK' - result = config.map_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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_oldstyle_class_context_and_request_with_attr(self): + def test__map_view_as_oldstyle_class_context_and_request_with_attr(self): config = self._makeOne() class view: def __init__(self, context, request): pass def index(self): return 'OK' - result = config.map_view(view, attr='index') + 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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_oldstyle_class_context_and_request_attr_and_renderer( + def test__map_view_as_oldstyle_class_context_and_request_attr_and_renderer( self): config = self._makeOne() self._registerRenderer(config) @@ -226,7 +994,7 @@ class ConfiguratorTests(unittest.TestCase): pass def index(self): return {'a':'1'} - result = config.map_view( + result = config._map_view( view, attr='index', renderer_name='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) @@ -236,35 +1004,35 @@ class ConfiguratorTests(unittest.TestCase): request = DummyRequest() self.assertEqual(result(None, request).body, 'Hello!') - def test_map_view_as_oldstyle_class_requestonly(self): + def test__map_view_as_oldstyle_class_requestonly(self): config = self._makeOne() class view: def __init__(self, request): pass def __call__(self): return 'OK' - result = config.map_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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_oldstyle_class_requestonly_with_attr(self): + def test__map_view_as_oldstyle_class_requestonly_with_attr(self): config = self._makeOne() class view: def __init__(self, request): pass def index(self): return 'OK' - result = config.map_view(view, attr='index') + 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.assertEqual(view.__name__, result.__name__) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_oldstyle_class_requestonly_attr_and_renderer(self): + def test__map_view_as_oldstyle_class_requestonly_attr_and_renderer(self): config = self._makeOne() self._registerRenderer(config) class view: @@ -272,7 +1040,7 @@ class ConfiguratorTests(unittest.TestCase): pass def index(self): return {'a':'1'} - result = config.map_view( + result = config._map_view( view, attr='index', renderer_name='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) @@ -282,74 +1050,74 @@ class ConfiguratorTests(unittest.TestCase): request = DummyRequest() self.assertEqual(result(None, request).body, 'Hello!') - def test_map_view_as_instance_context_and_request(self): + def test__map_view_as_instance_context_and_request(self): config = self._makeOne() class View: def __call__(self, context, request): return 'OK' view = View() - result = config.map_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): + def test__map_view_as_instance_context_and_request_and_attr(self): config = self._makeOne() class View: def index(self, context, request): return 'OK' view = View() - result = config.map_view(view, attr='index') + result = config._map_view(view, attr='index') self.failIf(result is view) self.assertEqual(result(None, None), 'OK') - def test_map_view_as_instance_context_and_request_attr_and_renderer(self): + def test__map_view_as_instance_context_and_request_attr_and_renderer(self): config = self._makeOne() self._registerRenderer(config) class View: def index(self, context, request): return {'a':'1'} view = View() - result = config.map_view( + result = config._map_view( view, attr='index', renderer_name='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) request = DummyRequest() self.assertEqual(result(None, request).body, 'Hello!') - def test_map_view_as_instance_requestonly(self): + def test__map_view_as_instance_requestonly(self): config = self._makeOne() class View: def __call__(self, request): return 'OK' view = View() - result = config.map_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') - def test_map_view_as_instance_requestonly_with_attr(self): + def test__map_view_as_instance_requestonly_with_attr(self): config = self._makeOne() class View: def index(self, request): return 'OK' view = View() - result = config.map_view(view, attr='index') + 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): + 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( + result = config._map_view( view, attr='index', renderer_name='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) @@ -359,12 +1127,12 @@ class ConfiguratorTests(unittest.TestCase): request = DummyRequest() self.assertEqual(result(None, request).body, 'Hello!') - def test_map_view_rendereronly(self): + def test__map_view_rendereronly(self): config = self._makeOne() self._registerRenderer(config) def view(context, request): return {'a':'1'} - result = config.map_view( + result = config._map_view( view, renderer_name='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) @@ -373,23 +1141,18 @@ class ConfiguratorTests(unittest.TestCase): request = DummyRequest() self.assertEqual(result(None, request).body, 'Hello!') - def test_map_view_defaultrendereronly(self): + 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) + result = config._map_view(view) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) request = DummyRequest() self.assertEqual(result(None, request).body, 'Hello!') - def _callDefaultConfiguration(self, *arg, **kw): - inst = self._makeOne() - inst.default_configuration(*arg, **kw) - return inst.reg - def test_default_config_fixtureapp_default_filename_withpackage(self): manager = DummyRegistryManager() from repoze.bfg.tests import fixtureapp @@ -627,3 +1390,9 @@ class DummyOverrides: def insert(self, path, package, prefix): self.inserted.append((path, package, prefix)) +from zope.interface import Interface +class IDummy(Interface): + pass + +class IOther(Interface): + pass diff --git a/repoze/bfg/tests/test_request.py b/repoze/bfg/tests/test_request.py index eb26b07cf..7d9e956ae 100644 --- a/repoze/bfg/tests/test_request.py +++ b/repoze/bfg/tests/test_request.py @@ -155,6 +155,7 @@ class Test_route_request_iface(unittest.TestCase): iface = self._callFUT('routename') self.failUnless(iface.extends(IRouteRequest)) self.failUnless(iface.extends(IRequest)) + self.assertEqual(iface.__name__, 'routename_IRequest') class Test_add_global_response_headers(unittest.TestCase): def _callFUT(self, request, headerlist): diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py index 7caf2a596..3dc55957e 100644 --- a/repoze/bfg/tests/test_zcml.py +++ b/repoze/bfg/tests/test_zcml.py @@ -17,2410 +17,415 @@ class TestViewDirective(unittest.TestCase): from repoze.bfg.zcml import view return view(*arg, **kw) - def test_no_view(self): - from zope.configuration.exceptions import ConfigurationError - context = DummyContext() - self.assertRaises(ConfigurationError, self._callFUT, context, - 'repoze.view', None) - - def test_view_as_function(self): - from zope.component import getSiteManager + def test_request_type_ashttpmethod(self): from zope.interface import Interface - from repoze.bfg.interfaces import IRequest + from zope.component import getSiteManager from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission + from repoze.bfg.interfaces import IRequest context = DummyContext() class IFoo(Interface): pass view = lambda *arg: None - self._callFUT(context, 'repoze.view', IFoo, view=view) + self._callFUT(context, 'repoze.view', IFoo, view=view, + request_type='GET') actions = context.actions self.assertEqual(len(actions), 1) action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, + discrim = ('view', IFoo, '', None, IView, None, None, 'GET', None, None, False, None, None, None) self.assertEqual(action['discriminator'], discrim) register = action['callable'] register() sm = getSiteManager() wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.failUnless(wrapper) - self.failIf(hasattr(wrapper, '__call_permissive__')) - - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) - - def test_view_as_function_requestonly(self): - from zope.interface import Interface + request = DummyRequest() + request.method = 'GET' + self.assertEqual(wrapper.__predicated__(None, request), True) + request.method = 'POST' + self.assertEqual(wrapper.__predicated__(None, request), False) + + def test_request_type_asinterfacestring(self): from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest + from zope.interface import Interface from repoze.bfg.interfaces import IView from repoze.bfg.interfaces import IViewPermission - - context = DummyContext() - - def view(request): - return 'OK' class IFoo(Interface): pass - - self._callFUT(context, 'repoze.view', IFoo, view=view) + class IRequest(Interface): + pass + context = DummyContext(IRequest) + view = lambda *arg: None + self._callFUT(context, 'repoze.view', IFoo, view=view, + request_type='whatever') actions = context.actions self.assertEqual(len(actions), 1) - action = actions[0] discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] + self.assertEqual(actions[0]['discriminator'], discrim) + register = actions[0]['callable'] register() sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.failIfEqual(wrapper, view) - self.assertEqual(wrapper.__module__, view.__module__) - self.assertEqual(wrapper.__name__, view.__name__) - self.assertEqual(wrapper.__doc__, view.__doc__) - result = wrapper(None, None) - self.assertEqual(result, 'OK') - self.failIf(hasattr(wrapper, '__call_permissive__')) + regview = sm.adapters.lookup((IFoo, IRequest), IView, name='') + self.assertEqual(view, regview) + self.failIf(hasattr(view, '__call_permissive__')) perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') self.assertEqual(perm, None) - def test_view_as_instance(self): - from zope.interface import Interface - from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission - - context = DummyContext() - class AView: - def __call__(self, context, request): - """ """ - view = AView() - class IFoo(Interface): - pass - self._callFUT(context, 'repoze.view', IFoo, view=view) - actions = context.actions - self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.failUnless(wrapper) - self.failIf(hasattr(wrapper, '__call_permissive__')) +class TestNotFoundDirective(unittest.TestCase): + def setUp(self): + testing.setUp() - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) + def tearDown(self): + testing.tearDown() - def test_view_as_instance_requestonly(self): - from zope.interface import Interface + def _callFUT(self, context, view): + from repoze.bfg.zcml import notfound + return notfound(context, view) + + def test_it(self): from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission + from repoze.bfg.interfaces import INotFoundView context = DummyContext() - class AView: - def __call__(self, request): - return 'OK' - view = AView() - class IFoo(Interface): - pass - self._callFUT(context, 'repoze.view', IFoo, view=view) + def view(request): + return 'OK' + self._callFUT(context, view) actions = context.actions self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], INotFoundView) + register = regadapt['callable'] register() sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.failIfEqual(wrapper, view) - self.assertEqual(wrapper.__module__, view.__module__) - self.failUnless('instance' in wrapper.__name__) - self.assertEqual(wrapper.__doc__, view.__doc__) - result = wrapper(None, None) - self.assertEqual(result, 'OK') - self.failIf(hasattr(wrapper, '__call_permissive__')) + derived_view = sm.getUtility(INotFoundView) + self.assertEqual(derived_view(None, None), 'OK') + self.assertEqual(derived_view.__name__, view.__name__) - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) +class TestForbiddenDirective(unittest.TestCase): + def setUp(self): + testing.setUp() - def test_view_as_oldstyle_class(self): - from zope.interface import Interface + def tearDown(self): + testing.tearDown() + + def _callFUT(self, context, view): + from repoze.bfg.zcml import forbidden + return forbidden(context, view) + + def test_it(self): from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission context = DummyContext() - class IFoo(Interface): - pass - class view: - def __init__(self, context, request): - self.context = context - self.request = request - - def __call__(self): - return self - self._callFUT(context, 'repoze.view', IFoo, view=view) + def view(request): + return 'OK' + self._callFUT(context, view) actions = context.actions + from repoze.bfg.interfaces import IForbiddenView self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IForbiddenView) + register = regadapt['callable'] register() sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.assertEqual(wrapper.__module__, view.__module__) - self.assertEqual(wrapper.__name__, view.__name__) - self.assertEqual(wrapper.__doc__, view.__doc__) - result = wrapper(None, None) - self.assertEqual(result.context, None) - self.assertEqual(result.request, None) - self.failIf(hasattr(wrapper, '__call_permissive__')) + derived_view = sm.getUtility(IForbiddenView) + self.assertEqual(derived_view(None, None), 'OK') + self.assertEqual(derived_view.__name__, view.__name__) - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) +class TestViewUtility(unittest.TestCase): + def setUp(self): + testing.setUp() - def test_view_as_oldstyle_class_requestonly(self): - from zope.interface import Interface - from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission + def tearDown(self): + testing.tearDown() + + def _callFUT(self, context, view, attr, renderer, wrapper, iface): + from repoze.bfg.zcml import view_utility + return view_utility(context, view, attr, renderer, wrapper, iface) + def test_no_view_no_renderer(self): + from zope.configuration.exceptions import ConfigurationError context = DummyContext() - class IFoo(Interface): + self.assertRaises(ConfigurationError, self._callFUT, context, + None, None, None, None, None) + + def test_no_view_with_renderer(self): + from zope.component import getSiteManager + from zope.interface import Interface + from repoze.bfg.interfaces import IRendererFactory + sm = getSiteManager() + def renderer(path): + return lambda *arg: 'OK' + sm.registerUtility(renderer, IRendererFactory, name='dummy') + class IDummy(Interface): pass - class view: - def __init__(self, request): - self.request = request - - def __call__(self): - return self - self._callFUT(context, 'repoze.view', IFoo, view=view) + context = DummyContext() + self._callFUT(context, None, None, 'dummy', None, IDummy) actions = context.actions self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IDummy) + register = regadapt['callable'] register() - sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.assertEqual(wrapper.__module__, view.__module__) - self.assertEqual(wrapper.__name__, view.__name__) - self.assertEqual(wrapper.__doc__, view.__doc__) - result = wrapper(None, None) - self.assertEqual(result.request, None) - self.failIf(hasattr(wrapper, '__call_permissive__')) - - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) - + derived_view = sm.getUtility(IDummy) + request = DummyRequest() + self.assertEqual(derived_view(None, request).body, 'OK') - def test_view_as_newstyle_class(self): - from zope.interface import Interface + def test_template_renderer(self): from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission - - context = DummyContext() - class IFoo(Interface): + from zope.interface import Interface + from repoze.bfg.interfaces import IRendererFactory + sm = getSiteManager() + def renderer(path): + return lambda *arg: 'OK' + sm.registerUtility(renderer, IRendererFactory, name='.pt') + class IDummy(Interface): pass - class view(object): - def __init__(self, context, request): - self.context = context - self.request = request - - def __call__(self): - return self - self._callFUT(context, 'repoze.view', IFoo, view=view) + context = DummyContext() + self._callFUT(context, None, None, 'fixtures/minimal.pt', None, IDummy) actions = context.actions self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IDummy) + register = regadapt['callable'] register() - sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.assertEqual(wrapper.__module__, view.__module__) - self.assertEqual(wrapper.__name__, view.__name__) - self.assertEqual(wrapper.__doc__, view.__doc__) - result = wrapper(None, None) - self.assertEqual(result.context, None) - self.assertEqual(result.request, None) - self.failIf(hasattr(wrapper, '__call_permissive__')) + derived_view = sm.getUtility(IDummy) + request = DummyRequest() + self.assertEqual(derived_view(None, request).body, 'OK') - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) +class TestRepozeWho1AuthenticationPolicyDirective(unittest.TestCase): + def setUp(self): + testing.setUp() - def test_view_as_newstyle_class_requestonly(self): - from zope.interface import Interface - from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission + def tearDown(self): + testing.tearDown() - context = DummyContext() - class IFoo(Interface): - pass - class view(object): - def __init__(self, request): - self.request = request + def _callFUT(self, context, **kw): + from repoze.bfg.zcml import repozewho1authenticationpolicy + return repozewho1authenticationpolicy(context, **kw) - def __call__(self): - return self - self._callFUT(context, 'repoze.view', IFoo, view=view) + def test_it_defaults(self): + from zope.component import getUtility + from repoze.bfg.interfaces import IAuthenticationPolicy + context = DummyContext() + self._callFUT(context) actions = context.actions self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.assertEqual(wrapper.__module__, view.__module__) - self.assertEqual(wrapper.__name__, view.__name__) - self.assertEqual(wrapper.__doc__, view.__doc__) - result = wrapper(None, None) - self.assertEqual(result.request, None) - self.failIf(hasattr(wrapper, '__call_permissive__')) - - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) - - def test_with_reltemplate(self): - from zope.interface import Interface - from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRendererFactory - import repoze.bfg.tests - - context = DummyContext(repoze.bfg.tests) - class IFoo(Interface): - pass - class view(object): - def __init__(self, context, request): - self.request = request - self.context = context - - def __call__(self): - return {'a':'1'} - - class Renderer: - def __call__(self, path): - self.path = path - return lambda *arg: 'Hello!' - - renderer = Renderer() - sm = getSiteManager() - sm.registerUtility(renderer, IRendererFactory, name='.txt') - - fixture = 'fixtures/minimal.txt' - self._callFUT(context, 'repoze.view', IFoo, view=view, renderer=fixture) - actions = context.actions - self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.assertEqual(wrapper.__module__, view.__module__) - self.assertEqual(wrapper.__name__, view.__name__) - self.assertEqual(wrapper.__doc__, view.__doc__) - request = DummyRequest() - result = wrapper(None, request) - self.assertEqual(result.body, 'Hello!') - self.assertEqual(renderer.path, 'repoze.bfg.tests:fixtures/minimal.txt') - - def test_with_template_no_view_callable(self): - from zope.interface import Interface - from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRendererFactory - - import repoze.bfg.tests - - context = DummyContext(repoze.bfg.tests) - class IFoo(Interface): - pass - sm = getSiteManager() - def renderer_factory(path): - return lambda *arg: 'Hello!' - sm.registerUtility(renderer_factory, IRendererFactory, name='.txt') - - self._callFUT(context, 'repoze.view', IFoo, renderer='foo.txt') - actions = context.actions - self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.environ = {} - result = wrapper(None, request) - self.assertEqual(result.body, 'Hello!') - - def test_request_type_asinterface(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission - class IRequest(Interface): - pass - class IFoo(Interface): - pass - context = DummyContext(IRequest) - view = lambda *arg: None - self._callFUT(context, 'repoze.view', IFoo, view=view, - request_type=IDummy) - actions = context.actions - - self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', IDummy, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IDummy), IView, name='') - self.failUnless(wrapper) - self.failIf(hasattr(wrapper, '__call_permissive__')) - - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) - - def test_request_type_as_noninterface(self): - from zope.component import getSiteManager - from zope.interface import Interface - from zope.interface import implementedBy - from repoze.bfg.interfaces import IView - class IFoo(Interface): - pass - class Dummy: - pass - context = DummyContext(Dummy) - view = lambda *arg: None - self._callFUT(context, 'repoze.view', IFoo, view=view, - request_type=Dummy) - actions = context.actions - - self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', Dummy, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - sm = getSiteManager() - iface = implementedBy(Dummy) - wrapper = sm.adapters.lookup((IFoo, iface), IView, name='') - self.failUnless(wrapper) - self.failIf(hasattr(wrapper, '__call_permissive__')) - - def test_request_type_ashttpmethod(self): - from zope.interface import Interface - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRequest + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) + self.assertEqual(regadapt['callable'], None) + self.assertEqual(regadapt['args'], ()) + policy = getUtility(IAuthenticationPolicy) + self.assertEqual(policy.callback, None) + self.assertEqual(policy.identifier_name, 'auth_tkt') + + def test_it(self): + from zope.component import getUtility + from repoze.bfg.interfaces import IAuthenticationPolicy context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - self._callFUT(context, 'repoze.view', IFoo, view=view, - request_type='GET') - actions = context.actions - - self.assertEqual(len(actions), 1) - - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, 'GET', None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.method = 'GET' - self.assertEqual(wrapper.__predicated__(None, request), True) - request.method = 'POST' - self.assertEqual(wrapper.__predicated__(None, request), False) - - - def test_request_type_asinterfacestring(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission - class IFoo(Interface): - pass - class IRequest(Interface): - pass - context = DummyContext(IRequest) - view = lambda *arg: None - self._callFUT(context, 'repoze.view', IFoo, view=view, - request_type='whatever') + def callback(identity, request): + """ """ + self._callFUT(context, identifier_name='something', callback=callback) actions = context.actions self.assertEqual(len(actions), 1) + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) + self.assertEqual(regadapt['callable'], None) + self.assertEqual(regadapt['args'], ()) + policy = getUtility(IAuthenticationPolicy) + self.assertEqual(policy.callback, callback) + self.assertEqual(policy.identifier_name, 'something') - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(actions[0]['discriminator'], discrim) - register = actions[0]['callable'] - register() - sm = getSiteManager() - regview = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.assertEqual(view, regview) - self.failIf(hasattr(view, '__call_permissive__')) - - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, None) - - def test_with_route_name(self): - from zope.interface import Interface - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: '123' - self._callFUT(context, 'repoze.view', IFoo, view=view, route_name='foo') - actions = context.actions +class TestRemoteUserAuthenticationPolicyDirective(unittest.TestCase): + def setUp(self): + testing.setUp() - self.assertEqual(len(actions), 1) + def tearDown(self): + testing.tearDown() - action = actions[0] - register = action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'foo') - discrim = ('view', IFoo, '', request_type, IView, None, None, None, - 'foo', None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - the_view = sm.adapters.lookup((IFoo, request_type), IView, name='') - request = DummyRequest({}) - self.assertEqual(the_view(None, request), '123') + def _callFUT(self, context, **kw): + from repoze.bfg.zcml import remoteuserauthenticationpolicy + return remoteuserauthenticationpolicy(context, **kw) - def test_with_request_method_true(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView + def test_defaults(self): + from repoze.bfg.interfaces import IAuthenticationPolicy + from zope.component import getUtility context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - self._callFUT(context, None, IFoo, view=view, request_method='POST') + def callback(identity, request): + """ """ + self._callFUT(context) actions = context.actions self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, 'POST', None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.method = 'POST' - self.assertEqual(wrapper(None, request), '123') + regadapt = actions[0] + regadapt_discriminator = 'authentication_policy' + self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) + self.assertEqual(regadapt['callable'], None) + self.assertEqual(regadapt['args'], ()) + policy = getUtility(IAuthenticationPolicy) + self.assertEqual(policy.environ_key, 'REMOTE_USER') + self.assertEqual(policy.callback, None) - def test_with_request_method_false(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound + def test_it(self): + from zope.component import getUtility + from repoze.bfg.interfaces import IAuthenticationPolicy context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): + def callback(identity, request): """ """ - self._callFUT(context, None, IFoo, view=view, request_method='POST') + self._callFUT(context, environ_key='BLAH', callback=callback) actions = context.actions self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, 'POST', None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.method = 'GET' - self.assertRaises(NotFound, wrapper, None, request) + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) + self.assertEqual(regadapt['callable'], None) + self.assertEqual(regadapt['args'], ()) + policy = getUtility(IAuthenticationPolicy) + self.assertEqual(policy.environ_key, 'BLAH') + self.assertEqual(policy.callback, callback) - def test_with_request_param_noval_true(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - self._callFUT(context, None, IFoo, view=view, request_param='abc') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.params = {'abc':''} - self.assertEqual(wrapper(None, request), '123') - - def test_with_request_param_noval_false(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound - context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, request_param='abc') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.params = {} - self.assertRaises(NotFound, wrapper, None, request) - - def test_with_request_param_val_true(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - self._callFUT(context, None, IFoo, view=view, request_param='abc=123') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, 'abc=123', None, - None, None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.params = {'abc':'123'} - self.assertEqual(wrapper(None, request), '123') - - def test_with_request_param_val_false(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound - context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, request_param='abc=123') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, 'abc=123', None, - None, None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.params = {'abc':'456'} - self.assertRaises(NotFound, wrapper, None, request) - - def test_with_xhr_true(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - self._callFUT(context, None, IFoo, view=view, xhr=True) - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, True, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.is_xhr = True - self.assertEqual(wrapper(None, request), '123') - - def test_with_xhr_false(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, xhr=True) - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, True, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.is_xhr = False - self.assertRaises(NotFound, wrapper, None, request) - - def test_with_header_badregex(self): - from zope.component import getSiteManager - from zope.interface import Interface - from zope.configuration.exceptions import ConfigurationError - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, header='Host:a\\') - self.assertRaises(ConfigurationError, context.actions[-1]['callable']) - - def test_with_header_noval_match(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - self._callFUT(context, None, IFoo, view=view, header='Host') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, 'Host', None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.headers = {'Host':'whatever'} - self.assertEqual(wrapper(None, request), '123') - - def test_with_header_noval_nomatch(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, header='Host') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, 'Host', None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.headers = {'NotHost':'whatever'} - self.assertRaises(NotFound, wrapper, None, request) - - def test_with_header_val_match(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - self._callFUT(context, None, IFoo, view=view, header=r'Host:\d') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, r'Host:\d', None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.headers = {'Host':'1'} - self.assertEqual(wrapper(None, request), '123') - - def test_with_header_val_nomatch(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, header=r'Host:\d') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, r'Host:\d', None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.headers = {'Host':'abc'} - self.assertRaises(NotFound, wrapper, None, request) - - def test_with_accept_match(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - self._callFUT(context, None, IFoo, view=view, accept='text/xml') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, 'text/xml', None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.accept = ['text/xml'] - self.assertEqual(wrapper(None, request), '123') - - def test_with_accept_nomatch(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, accept='text/xml') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, 'text/xml', None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - request.accept = ['text/html'] - self.assertRaises(NotFound, wrapper, None, request) - - def test_with_containment_true(self): - from zope.component import getSiteManager - from zope.interface import directlyProvides - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - sm.registerAdapter(view, (IFoo, IRequest), IView, name='') - self._callFUT(context, None, IFoo, view=view, containment=IFoo) - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, IFoo, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - context = Dummy() - directlyProvides(context, IFoo) - self.assertEqual(wrapper(context, request), '123') - - def test_with_containment_false(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound - context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, containment=IFoo) - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, IFoo, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest() - context = Dummy() - self.assertRaises(NotFound, wrapper, context, request) - - def test_with_path_info_badregex(self): - from zope.component import getSiteManager - from zope.interface import Interface - from zope.configuration.exceptions import ConfigurationError - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view, path_info='\\') - self.assertRaises(ConfigurationError, context.actions[-1]['callable']) - - def test_with_path_info_match(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): - return '123' - self._callFUT(context, None, IFoo, view=view, path_info='/foo') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, '/foo') - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest({'PATH_INFO': '/foo'}) - self.assertEqual(wrapper(None, request), '123') - - def test_with_path_info_nomatch(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.exceptions import NotFound - class IFoo(Interface): - pass - context = DummyContext() - view = lambda *arg: None - sm = getSiteManager() - def view(context, request): pass - self._callFUT(context, None, IFoo, view=view, path_info='/boo') - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, '/boo') - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - request = DummyRequest({'PATH_INFO': '/foo'}) - self.assertRaises(NotFound, wrapper, None, request) - - def test_multiview_replaces_traditional_view(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IMultiView - from repoze.bfg.interfaces import IViewPermission - context = DummyContext() - class IFoo(Interface): - pass - sm = getSiteManager() - def view(context, request): - return '123' - sm.registerAdapter(view, (IFoo, IRequest), IView, name='') - self._callFUT(context, 'repoze.view', IFoo, view=view) - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - self.failUnless(IMultiView.providedBy(wrapper)) - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, wrapper.__permitted__) - self.assertEqual(wrapper(None, None), '123') - - def test_multiview_call_ordering(self): - from zope.component import getSiteManager - from zope.interface import Interface - from zope.interface import directlyProvides - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - context = DummyContext() - class IFoo(Interface): - pass - def view1(context, request): return 'view1' - def view2(context, request): return 'view2' - def view3(context, request): return 'view3' - def view4(context, request): return 'view4' - def view5(context, request): return 'view5' - def view6(context, request): return 'view6' - def view7(context, request): return 'view7' - def view8(context, request): return 'view8' - self._callFUT(context, 'repoze.view', IFoo, view=view1) - self._callFUT(context, 'repoze.view', IFoo, view=view2, - request_method='POST') - self._callFUT(context, 'repoze.view', IFoo, view=view3, - request_param='param') - self._callFUT(context, 'repoze.view', IFoo, view=view4, - containment=IFoo) - self._callFUT(context, 'repoze.view', IFoo, view=view5, - request_method='POST', request_param='param') - self._callFUT(context, 'repoze.view', IFoo, view=view6, - request_method='POST', containment=IFoo) - self._callFUT(context, 'repoze.view', IFoo, view=view7, - request_param='param', containment=IFoo) - self._callFUT(context, 'repoze.view', IFoo, view=view8, - request_type='POST', request_param='param', - containment=IFoo) - for action in context.actions: - register = action['callable'] - register() - - sm = getSiteManager() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - - ctx = Dummy() - request = DummyRequest() - request.method = 'GET' - request.params = {} - self.assertEqual(wrapper(ctx, request), 'view1') - - ctx = Dummy() - request = DummyRequest() - request.params = {} - request.method = 'POST' - self.assertEqual(wrapper(ctx, request), 'view2') - - ctx = Dummy() - request = DummyRequest() - request.params = {'param':'1'} - request.method = 'GET' - self.assertEqual(wrapper(ctx, request), 'view3') - - ctx = Dummy() - directlyProvides(ctx, IFoo) - request = DummyRequest() - request.method = 'GET' - request.params = {} - self.assertEqual(wrapper(ctx, request), 'view4') - - ctx = Dummy() - request = DummyRequest() - request.method = 'POST' - request.params = {'param':'1'} - self.assertEqual(wrapper(ctx, request), 'view5') - - ctx = Dummy() - directlyProvides(ctx, IFoo) - request = DummyRequest() - request.params = {} - request.method = 'POST' - self.assertEqual(wrapper(ctx, request), 'view6') - - ctx = Dummy() - directlyProvides(ctx, IFoo) - request = DummyRequest() - request.method = 'GET' - request.params = {'param':'1'} - self.assertEqual(wrapper(ctx, request), 'view7') - - ctx = Dummy() - directlyProvides(ctx, IFoo) - request = DummyRequest() - request.method = 'POST' - request.params = {'param':'1'} - self.assertEqual(wrapper(ctx, request), 'view8') - - def test_multiview_replaces_multiview(self): - from zope.component import getSiteManager - from zope.interface import Interface - from zope.interface import implements - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IMultiView - from repoze.bfg.interfaces import IViewPermission - context = DummyContext() - class IFoo(Interface): - pass - view = lambda *arg: None - sm = getSiteManager() - class DummyMultiView: - implements(IMultiView) - def __init__(self): - self.views = [] - self.name = 'name' - def add(self, view, score): - self.views.append(view) - def __call__(self, context, request): - return '123' - def __permitted__(self, context, request): - """ """ - view = DummyMultiView() - sm.registerAdapter(view, (IFoo, IRequest), IMultiView, name='') - def view2(context, request): - """ """ - self._callFUT(context, None, IFoo, view=view2) - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='') - self.assertEqual(perm, wrapper.__permitted__) - self.failUnless(IMultiView.providedBy(wrapper)) - self.assertEqual(wrapper(None, None), '123') - self.assertEqual(wrapper.views, [view2]) - - def test_for_as_class(self): - from zope.component import getSiteManager - from zope.interface import implementedBy - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - context = DummyContext() - class Foo: - pass - sm = getSiteManager() - def view(context, request): - """ """ - self._callFUT(context, 'repoze.view', Foo, view=view) - actions = context.actions - self.assertEqual(len(actions), 1) - action = actions[0] - discrim = ('view', Foo, '', IRequest, IView, None, None, None, None, - None, False, None, None, None) - self.assertEqual(action['discriminator'], discrim) - register = action['callable'] - register() - foo = implementedBy(Foo) - wrapper = sm.adapters.lookup((foo, IRequest), IView, name='') - self.assertEqual(wrapper, view) - -class TestNotFoundDirective(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, context, view): - from repoze.bfg.zcml import notfound - return notfound(context, view) - - def test_it(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import INotFoundView - - context = DummyContext() - def view(request): - return 'OK' - self._callFUT(context, view) - actions = context.actions - self.assertEqual(len(actions), 1) - - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], INotFoundView) - register = regadapt['callable'] - register() - sm = getSiteManager() - derived_view = sm.getUtility(INotFoundView) - self.assertEqual(derived_view(None, None), 'OK') - self.assertEqual(derived_view.__name__, view.__name__) - -class TestForbiddenDirective(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, context, view): - from repoze.bfg.zcml import forbidden - return forbidden(context, view) - - def test_it(self): - from zope.component import getSiteManager - context = DummyContext() - def view(request): - return 'OK' - self._callFUT(context, view) - actions = context.actions - from repoze.bfg.interfaces import IForbiddenView - - self.assertEqual(len(actions), 1) - - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IForbiddenView) - register = regadapt['callable'] - register() - sm = getSiteManager() - derived_view = sm.getUtility(IForbiddenView) - self.assertEqual(derived_view(None, None), 'OK') - self.assertEqual(derived_view.__name__, view.__name__) - -class TestViewUtility(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, context, view, attr, renderer, wrapper, iface): - from repoze.bfg.zcml import view_utility - return view_utility(context, view, attr, renderer, wrapper, iface) - - def test_no_view_no_renderer(self): - from zope.configuration.exceptions import ConfigurationError - context = DummyContext() - self.assertRaises(ConfigurationError, self._callFUT, context, - None, None, None, None, None) - - def test_no_view_with_renderer(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRendererFactory - sm = getSiteManager() - def renderer(path): - return lambda *arg: 'OK' - sm.registerUtility(renderer, IRendererFactory, name='dummy') - class IDummy(Interface): - pass - context = DummyContext() - self._callFUT(context, None, None, 'dummy', None, IDummy) - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IDummy) - register = regadapt['callable'] - register() - derived_view = sm.getUtility(IDummy) - request = DummyRequest() - self.assertEqual(derived_view(None, request).body, 'OK') - - def test_template_renderer(self): - from zope.component import getSiteManager - from zope.interface import Interface - from repoze.bfg.interfaces import IRendererFactory - sm = getSiteManager() - def renderer(path): - return lambda *arg: 'OK' - sm.registerUtility(renderer, IRendererFactory, name='.pt') - class IDummy(Interface): - pass - context = DummyContext() - self._callFUT(context, None, None, 'fixtures/minimal.pt', None, IDummy) - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IDummy) - register = regadapt['callable'] - register() - derived_view = sm.getUtility(IDummy) - request = DummyRequest() - self.assertEqual(derived_view(None, request).body, 'OK') - -class TestRepozeWho1AuthenticationPolicyDirective(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, context, **kw): - from repoze.bfg.zcml import repozewho1authenticationpolicy - return repozewho1authenticationpolicy(context, **kw) - - def test_it_defaults(self): - from zope.component import getUtility - from repoze.bfg.interfaces import IAuthenticationPolicy - context = DummyContext() - self._callFUT(context) - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) - self.assertEqual(regadapt['callable'], None) - self.assertEqual(regadapt['args'], ()) - policy = getUtility(IAuthenticationPolicy) - self.assertEqual(policy.callback, None) - self.assertEqual(policy.identifier_name, 'auth_tkt') - - def test_it(self): - from zope.component import getUtility - from repoze.bfg.interfaces import IAuthenticationPolicy - context = DummyContext() - def callback(identity, request): - """ """ - self._callFUT(context, identifier_name='something', callback=callback) - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) - self.assertEqual(regadapt['callable'], None) - self.assertEqual(regadapt['args'], ()) - policy = getUtility(IAuthenticationPolicy) - self.assertEqual(policy.callback, callback) - self.assertEqual(policy.identifier_name, 'something') - -class TestRemoteUserAuthenticationPolicyDirective(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, context, **kw): - from repoze.bfg.zcml import remoteuserauthenticationpolicy - return remoteuserauthenticationpolicy(context, **kw) - - def test_defaults(self): - from repoze.bfg.interfaces import IAuthenticationPolicy - from zope.component import getUtility - context = DummyContext() - def callback(identity, request): - """ """ - self._callFUT(context) - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - regadapt_discriminator = 'authentication_policy' - self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) - self.assertEqual(regadapt['callable'], None) - self.assertEqual(regadapt['args'], ()) - policy = getUtility(IAuthenticationPolicy) - self.assertEqual(policy.environ_key, 'REMOTE_USER') - self.assertEqual(policy.callback, None) - - def test_it(self): - from zope.component import getUtility - from repoze.bfg.interfaces import IAuthenticationPolicy - context = DummyContext() - def callback(identity, request): - """ """ - self._callFUT(context, environ_key='BLAH', callback=callback) - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) - self.assertEqual(regadapt['callable'], None) - self.assertEqual(regadapt['args'], ()) - policy = getUtility(IAuthenticationPolicy) - self.assertEqual(policy.environ_key, 'BLAH') - self.assertEqual(policy.callback, callback) - -class TestAuthTktAuthenticationPolicyDirective(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, context, secret, **kw): - from repoze.bfg.zcml import authtktauthenticationpolicy - return authtktauthenticationpolicy(context, secret, **kw) - - def test_it_defaults(self): - from zope.component import getUtility - from repoze.bfg.interfaces import IAuthenticationPolicy - context = DummyContext() - self._callFUT(context, 'sosecret') - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) - self.assertEqual(regadapt['callable'], None) - self.assertEqual(regadapt['args'], ()) - policy = getUtility(IAuthenticationPolicy) - self.assertEqual(policy.cookie.secret, 'sosecret') - self.assertEqual(policy.callback, None) - - def test_it_noconfigerror(self): - from zope.component import getUtility - from repoze.bfg.interfaces import IAuthenticationPolicy - context = DummyContext() - def callback(identity, request): - """ """ - self._callFUT(context, 'sosecret', callback=callback, - cookie_name='repoze.bfg.auth_tkt', - secure=True, include_ip=True, timeout=100, - reissue_time=60) - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) - self.assertEqual(regadapt['callable'], None) - self.assertEqual(regadapt['args'], ()) - policy = getUtility(IAuthenticationPolicy) - self.assertEqual(policy.cookie.secret, 'sosecret') - self.assertEqual(policy.callback, callback) - - def test_it_configerror(self): - from zope.configuration.exceptions import ConfigurationError - context = DummyContext() - def callback(identity, request): - """ """ - self.assertRaises(ConfigurationError, - self._callFUT, - context, 'sosecret', callback=callback, - cookie_name='repoze.bfg.auth_tkt', - secure=True, include_ip=True, timeout=100, - reissue_time=500) - -class TestACLAuthorizationPolicyDirective(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, context, **kw): - from repoze.bfg.zcml import aclauthorizationpolicy - return aclauthorizationpolicy(context, **kw) - - def test_it(self): - from zope.component import getUtility - from repoze.bfg.authorization import ACLAuthorizationPolicy - from repoze.bfg.interfaces import IAuthorizationPolicy - context = DummyContext() - def callback(identity, request): - """ """ - self._callFUT(context) - actions = context.actions - self.assertEqual(len(actions), 1) - regadapt = actions[0] - self.assertEqual(regadapt['discriminator'], IAuthorizationPolicy) - self.assertEqual(regadapt['callable'], None) - self.assertEqual(regadapt['args'], ()) - policy = getUtility(IAuthorizationPolicy) - self.assertEqual(policy.__class__, ACLAuthorizationPolicy) - -class TestRouteDirective(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, *arg, **kw): - from repoze.bfg.zcml import route - return route(*arg, **kw) - - def _assertRoute(self, name, path, num_predicates=0): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IRoutesMapper - sm = getSiteManager() - mapper = sm.getUtility(IRoutesMapper) - routes = mapper.get_routes() - route = routes[0] - self.assertEqual(len(routes), 1) - self.assertEqual(route.name, name) - self.assertEqual(route.path, path) - self.assertEqual(len(routes[0].predicates), num_predicates) - return route - - def test_defaults(self): - context = DummyContext() - self._callFUT(context, 'name', 'path') - actions = context.actions - self.assertEqual(len(actions), 1) - route_action = actions[0] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual( - route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view(self): - from zope.interface import Interface - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - from zope.component import getSiteManager - - context = DummyContext() - def view(context, request): - return '123' - self._callFUT(context, 'name', 'path', view=view) - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - register = view_action['callable'] - register() - wrapped = sm.adapters.lookup((Interface, request_type), IView, name='') - request = DummyRequest() - self.assertEqual(wrapped(None, request), '123') - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual( - route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_and_view_for(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - return '123' - self._callFUT(context, 'name', 'path', view=view, view_for=IDummy) - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', IDummy, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - request = DummyRequest() - self.assertEqual(wrapped(None, request), '123') - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual( - route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_and_view_for_alias(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - return '123' - self._callFUT(context, 'name', 'path', view=view, for_=IDummy) - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', IDummy, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - request = DummyRequest() - self.assertEqual(wrapped(None, request), '123') - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None,None)) - route_callable() - self._assertRoute('name', 'path') - - def test_without_view(self): - from repoze.bfg.interfaces import IRoutesMapper - from zope.component import getSiteManager - context = DummyContext() - self._callFUT(context, 'name', 'path') - actions = context.actions - self.assertEqual(len(actions), 1) - - route_action = actions[0] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - sm = getSiteManager() - mapper = sm.getUtility(IRoutesMapper) - routes = mapper.get_routes() - self.assertEqual(len(routes), 1) - self.assertEqual(routes[0].name, 'name') - self.assertEqual(routes[0].path, 'path') - self.failIf(routes[0].predicates) - - def test_with_view_request_type(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - view_request_type="GET") - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, 'GET', - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None,None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_request_type_alias(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - request_type="GET") - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, 'GET', - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - route_args = route_action['args'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None,None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_request_method(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - view_request_method="GET") - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, 'GET', - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_containment(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, view_containment=True) - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, True, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None,None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_header(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, view_header='Host') - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, 'Host', None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None,None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_path_info(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, view_path_info='/foo') - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, '/foo') - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_xhr(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, view_xhr=True) - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, True, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_accept(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - view_accept='text/xml') - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, 'text/xml', None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual( - route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_renderer(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - from repoze.bfg.interfaces import IRendererFactory - - sm = getSiteManager() - def renderer(name): - return lambda *x: 'foo' - sm.registerUtility(renderer, IRendererFactory, name='dummy') - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - view_renderer="dummy") - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_renderer_alias(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - from repoze.bfg.interfaces import IRendererFactory - - sm = getSiteManager() - def renderer(name): - return lambda *x: 'foo' - sm.registerUtility(renderer, IRendererFactory, name='dummy') - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - renderer="dummy") - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - - def test_with_view_permission(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - sm = getSiteManager() - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - view_permission="edit") - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_permission_alias(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - sm = getSiteManager() - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - permission="edit") - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_for(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - sm = getSiteManager() - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - view_for=IDummy) - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', IDummy, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_view_for_alias(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - sm = getSiteManager() - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, - for_=IDummy) - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', IDummy, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None, None)) - route_callable() - self._assertRoute('name', 'path') - - def test_with_request_type_GET(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, request_type="GET") - actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, 'GET', - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) +class TestAuthTktAuthenticationPolicyDirective(unittest.TestCase): + def setUp(self): + testing.setUp() - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None, None, None,None)) - route_callable() - self._assertRoute('name', 'path') + def tearDown(self): + testing.tearDown() - # route predicates + def _callFUT(self, context, secret, **kw): + from repoze.bfg.zcml import authtktauthenticationpolicy + return authtktauthenticationpolicy(context, secret, **kw) - def test_with_xhr(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - + def test_it_defaults(self): + from zope.component import getUtility + from repoze.bfg.interfaces import IAuthenticationPolicy context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, xhr=True) + self._callFUT(context, 'sosecret') actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', True, None, None, None, None, None)) - route_callable() - route = self._assertRoute('name', 'path', 1) - request = DummyRequest() - request.is_xhr = True - self.assertEqual(route.predicates[0](None, request), True) + self.assertEqual(len(actions), 1) + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) + self.assertEqual(regadapt['callable'], None) + self.assertEqual(regadapt['args'], ()) + policy = getUtility(IAuthenticationPolicy) + self.assertEqual(policy.cookie.secret, 'sosecret') + self.assertEqual(policy.callback, None) - def test_with_request_method(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - + def test_it_noconfigerror(self): + from zope.component import getUtility + from repoze.bfg.interfaces import IAuthenticationPolicy context = DummyContext() - def view(context, request): + def callback(identity, request): """ """ - self._callFUT(context, 'name', 'path', view=view, request_method="GET") + self._callFUT(context, 'sosecret', callback=callback, + cookie_name='repoze.bfg.auth_tkt', + secure=True, include_ip=True, timeout=100, + reissue_time=60) actions = context.actions - self.assertEqual(len(actions), 2) - - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') + self.assertEqual(len(actions), 1) + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy) + self.assertEqual(regadapt['callable'], None) + self.assertEqual(regadapt['args'], ()) + policy = getUtility(IAuthenticationPolicy) + self.assertEqual(policy.cookie.secret, 'sosecret') + self.assertEqual(policy.callback, callback) - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) + def test_it_configerror(self): + from zope.configuration.exceptions import ConfigurationError + context = DummyContext() + def callback(identity, request): + """ """ + self.assertRaises(ConfigurationError, + self._callFUT, + context, 'sosecret', callback=callback, + cookie_name='repoze.bfg.auth_tkt', + secure=True, include_ip=True, timeout=100, + reissue_time=500) - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, 'GET',None, None, None, None)) - route_callable() - route = self._assertRoute('name', 'path', 1) - request = DummyRequest() - request.method = 'GET' - self.assertEqual(route.predicates[0](None, request), True) +class TestACLAuthorizationPolicyDirective(unittest.TestCase): + def setUp(self): + testing.setUp() - def test_with_path_info(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest + def tearDown(self): + testing.tearDown() + def _callFUT(self, context, **kw): + from repoze.bfg.zcml import aclauthorizationpolicy + return aclauthorizationpolicy(context, **kw) + + def test_it(self): + from zope.component import getUtility + from repoze.bfg.authorization import ACLAuthorizationPolicy + from repoze.bfg.interfaces import IAuthorizationPolicy context = DummyContext() - def view(context, request): + def callback(identity, request): """ """ - self._callFUT(context, 'name', 'path', view=view, path_info='/foo') + self._callFUT(context) actions = context.actions - self.assertEqual(len(actions), 2) + self.assertEqual(len(actions), 1) + regadapt = actions[0] + self.assertEqual(regadapt['discriminator'], IAuthorizationPolicy) + self.assertEqual(regadapt['callable'], None) + self.assertEqual(regadapt['args'], ()) + policy = getUtility(IAuthorizationPolicy) + self.assertEqual(policy.__class__, ACLAuthorizationPolicy) - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) +class TestRouteDirective(unittest.TestCase): + def setUp(self): + testing.setUp() - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, '/foo',None,None, None)) - route_callable() - route = self._assertRoute('name', 'path', 1) - request = DummyRequest() - request.path_info = '/foo' - self.assertEqual(route.predicates[0](None, request), True) + def tearDown(self): + testing.tearDown() - def test_with_request_param(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, request_param='abc') - actions = context.actions - self.assertEqual(len(actions), 2) + def _callFUT(self, *arg, **kw): + from repoze.bfg.zcml import route + return route(*arg, **kw) - view_action = actions[0] - register = view_action['callable'] - register() + def _assertRoute(self, name, path, num_predicates=0): + from zope.component import getSiteManager + from repoze.bfg.interfaces import IRoutesMapper sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - route_args = route_action['args'] - self.assertEqual(route_discriminator, - ('route', 'name', False, None, None,'abc', None, None)) - route_callable() - route = self._assertRoute('name', 'path', 1) - request = DummyRequest() - request.params = {'abc':'123'} - self.assertEqual(route.predicates[0](None, request), True) + mapper = sm.getUtility(IRoutesMapper) + routes = mapper.get_routes() + route = routes[0] + self.assertEqual(len(routes), 1) + self.assertEqual(route.name, name) + self.assertEqual(route.path, path) + self.assertEqual(len(routes[0].predicates), num_predicates) + return route - def test_with_header(self): + def test_with_view(self): from zope.component import getSiteManager + from zope.interface import Interface from repoze.bfg.interfaces import IView from repoze.bfg.interfaces import IRouteRequest - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, header='Host') + view = lambda *arg: 'OK' + self._callFUT(context, 'name', 'path', view=view) actions = context.actions self.assertEqual(len(actions), 2) - view_action = actions[0] - register = view_action['callable'] - register() - sm = getSiteManager() - request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] - discrim = ('view', None, '', request_type, IView, None, None, None, - 'name', None, False, None, None, None) - self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') - self.failUnless(wrapped) - - route_action = actions[1] - route_callable = route_action['callable'] + route_action = actions[0] + route_action['callable']() route_discriminator = route_action['discriminator'] self.assertEqual(route_discriminator, - ('route', 'name', False, None, None,None,'Host', None)) - route_callable() - route = self._assertRoute('name', 'path', 1) - request = DummyRequest() - request.headers = {'Host':'example.com'} - self.assertEqual(route.predicates[0](None, request), True) - - def test_with_accept(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IRouteRequest - - context = DummyContext() - def view(context, request): - """ """ - self._callFUT(context, 'name', 'path', view=view, accept='text/xml') - actions = context.actions - self.assertEqual(len(actions), 2) + ('route', 'name', False, None, None, None, None,None)) + self._assertRoute('name', 'path') - view_action = actions[0] - register = view_action['callable'] - register() + view_action = actions[1] sm = getSiteManager() request_type = sm.getUtility(IRouteRequest, 'name') - view_discriminator = view_action['discriminator'] discrim = ('view', None, '', request_type, IView, None, None, None, 'name', None, False, None, None, None) self.assertEqual(view_discriminator, discrim) - wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='') + wrapped = sm.adapters.lookup((Interface, request_type), IView, name='') self.failUnless(wrapped) - route_action = actions[1] - route_callable = route_action['callable'] - route_discriminator = route_action['discriminator'] - self.assertEqual( - route_discriminator, - ('route', 'name', False, None, None, None, None, 'text/xml')) - route_callable() - route = self._assertRoute('name', 'path', 1) - request = DummyRequest() - request.accept = ['text/xml'] - self.assertEqual(route.predicates[0](None, request), True) + # route predicates class TestStaticDirective(unittest.TestCase): def setUp(self): @@ -2449,32 +454,30 @@ class TestStaticDirective(unittest.TestCase): actions = context.actions self.assertEqual(len(actions), 2) - action = actions[0] - discriminator = action['discriminator'] - self.assertEqual(discriminator[:3], ('view', StaticRootFactory, '')) - self.assertEqual(discriminator[4], IView) - sm = getSiteManager() - register = action['callable'] - register() sm = getSiteManager() - iface = implementedBy(StaticRootFactory) - request_type = sm.getUtility(IRouteRequest, 'name') - wrapped = sm.adapters.lookup((iface, request_type), IView, name='') - request = DummyRequest() - self.assertEqual(wrapped(None, request).__class__, StaticURLParser) - action = actions[1] - callable = action['callable'] - discriminator = action['discriminator'] + route_action = actions[0] + route_action['callable']() + discriminator = route_action['discriminator'] self.assertEqual(discriminator, ('route', 'name', False, None, None, None, None, None)) - action['callable']() mapper = sm.getUtility(IRoutesMapper) routes = mapper.get_routes() self.assertEqual(len(routes), 1) self.assertEqual(routes[0].path, 'name*subpath') self.assertEqual(routes[0].name, 'name') + + view_action = actions[1] + discriminator = view_action['discriminator'] + self.assertEqual(discriminator[:3], ('view', StaticRootFactory, '')) + self.assertEqual(discriminator[4], IView) + iface = implementedBy(StaticRootFactory) + request_type = sm.getUtility(IRouteRequest, 'name') + wrapped = sm.adapters.lookup((iface, request_type), IView, name='') + request = DummyRequest() + self.assertEqual(wrapped(None, request).__class__, StaticURLParser) + def test_package_relative(self): from repoze.bfg.static import PackageURLParser from zope.component import getSiteManager @@ -2488,30 +491,29 @@ class TestStaticDirective(unittest.TestCase): actions = context.actions self.assertEqual(len(actions), 2) - action = actions[0] - discriminator = action['discriminator'] - self.assertEqual(discriminator[:3], ('view', StaticRootFactory, '')) - self.assertEqual(discriminator[4], IView) - register = action['callable'] - register() sm = getSiteManager() - iface = implementedBy(StaticRootFactory) - request_type = sm.getUtility(IRouteRequest, 'name') - view = sm.adapters.lookup((iface, request_type), IView, name='') - request = DummyRequest() - self.assertEqual(view(None, request).__class__, PackageURLParser) - action = actions[1] - discriminator = action['discriminator'] + route_action = actions[0] + discriminator = route_action['discriminator'] self.assertEqual(discriminator, ('route', 'name', False, None, None, None, None, None)) - action['callable']() + route_action['callable']() mapper = sm.getUtility(IRoutesMapper) routes = mapper.get_routes() self.assertEqual(len(routes), 1) self.assertEqual(routes[0].path, 'name*subpath') self.assertEqual(routes[0].name, 'name') + view_action = actions[1] + discriminator = view_action['discriminator'] + self.assertEqual(discriminator[:3], ('view', StaticRootFactory, '')) + self.assertEqual(discriminator[4], IView) + iface = implementedBy(StaticRootFactory) + request_type = sm.getUtility(IRouteRequest, 'name') + view = sm.adapters.lookup((iface, request_type), IView, name='') + request = DummyRequest() + self.assertEqual(view(None, request).__class__, PackageURLParser) + def test_here_relative(self): from repoze.bfg.static import PackageURLParser from zope.component import getSiteManager @@ -2526,31 +528,28 @@ class TestStaticDirective(unittest.TestCase): actions = context.actions self.assertEqual(len(actions), 2) - action = actions[0] - discriminator = action['discriminator'] - self.assertEqual(discriminator[:3], ('view', StaticRootFactory, '')) - self.assertEqual(discriminator[4], IView) - register = action['callable'] - register() sm = getSiteManager() - iface = implementedBy(StaticRootFactory) - request_type = sm.getUtility(IRouteRequest, 'name') - wrapped = sm.adapters.lookup((iface, request_type), IView, name='') - request = DummyRequest() - self.assertEqual(wrapped(None, request).__class__, PackageURLParser) - - action = actions[1] - callable = action['callable'] - discriminator = action['discriminator'] + route_action = actions[0] + route_action['callable']() + discriminator = route_action['discriminator'] self.assertEqual(discriminator, ('route', 'name', False, None, None, None, None, None)) - action['callable']() mapper = sm.getUtility(IRoutesMapper) routes = mapper.get_routes() self.assertEqual(len(routes), 1) self.assertEqual(routes[0].path, 'name*subpath') self.assertEqual(routes[0].name, 'name') + view_action = actions[1] + discriminator = view_action['discriminator'] + self.assertEqual(discriminator[:3], ('view', StaticRootFactory, '')) + self.assertEqual(discriminator[4], IView) + iface = implementedBy(StaticRootFactory) + request_type = sm.getUtility(IRouteRequest, 'name') + wrapped = sm.adapters.lookup((iface, request_type), IView, name='') + request = DummyRequest() + self.assertEqual(wrapped(None, request).__class__, PackageURLParser) + class TestResourceDirective(unittest.TestCase): def setUp(self): testing.setUp() -- cgit v1.2.3