From d66bfb5d1f1aef5cce4941b49740dbd136c95605 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Sun, 6 Sep 2009 03:36:59 +0000 Subject: Merge multiview2 branch to HEAD. --- repoze/bfg/tests/test_view.py | 571 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 494 insertions(+), 77 deletions(-) (limited to 'repoze/bfg/tests/test_view.py') diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py index 3c7d6f853..f496ebb36 100644 --- a/repoze/bfg/tests/test_view.py +++ b/repoze/bfg/tests/test_view.py @@ -15,28 +15,6 @@ class BaseTest(object): from repoze.bfg.interfaces import IView gsm.registerAdapter(app, for_, IView, name) - def _registerViewPermission(self, view_name, allow=True): - import zope.component - from zope.interface import Interface - from repoze.bfg.interfaces import IViewPermission - class Checker(object): - def __call__(self, context, request): - self.context = context - self.request = request - return allow - checker = Checker() - gsm = zope.component.getGlobalSiteManager() - gsm.registerAdapter(checker, (Interface, Interface), - IViewPermission, - view_name) - return checker - - def _registerSecurityPolicy(self, secpol): - import zope.component - gsm = zope.component.getGlobalSiteManager() - from repoze.bfg.interfaces import ISecurityPolicy - gsm.registerUtility(secpol, ISecurityPolicy) - def _makeEnviron(self, **extras): environ = { 'wsgi.url_scheme':'http', @@ -61,7 +39,7 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase): result = self._callFUT(context, request, name='notregistered') self.assertEqual(result, None) - def test_call_view_registered_secure_permission_disallows(self): + def test_call_view_registered_secure(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -70,20 +48,18 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', False) environ = self._makeEnviron() from webob import Request request = Request(environ) directlyProvides(request, IRequest) - from repoze.bfg.security import Unauthorized - self.assertRaises(Unauthorized, self._callFUT, context, request, - name='registered', secure=True) + response = self._callFUT(context, request, name='registered', + secure=True) + self.assertEqual(response.status, '200 OK') + - def test_call_view_registered_secure_permission_allows(self): + def test_call_view_registered_insecure_no_call_permissive(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -92,20 +68,17 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', True) environ = self._makeEnviron() from webob import Request request = Request(environ) directlyProvides(request, IRequest) response = self._callFUT(context, request, name='registered', - secure=True) + secure=False) self.assertEqual(response.status, '200 OK') - def test_call_view_registered_insecure_permission_disallows(self): + def test_call_view_registered_insecure_with_call_permissive(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -114,11 +87,11 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) + def anotherview(context, request): + return DummyResponse('anotherview') + view.__call_permissive__ = anotherview self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', False) environ = self._makeEnviron() from webob import Request request = Request(environ) @@ -126,6 +99,7 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase): response = self._callFUT(context, request, name='registered', secure=False) self.assertEqual(response.status, '200 OK') + self.assertEqual(response.app_iter, ['anotherview']) class RenderViewToIterableTests(BaseTest, unittest.TestCase): def _callFUT(self, *arg, **kw): @@ -140,7 +114,7 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase): result = self._callFUT(context, request, name='notregistered') self.assertEqual(result, None) - def test_call_view_registered_secure_permission_disallows(self): + def test_call_view_registered_secure(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -149,20 +123,17 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', False) environ = self._makeEnviron() from webob import Request request = Request(environ) directlyProvides(request, IRequest) - from repoze.bfg.security import Unauthorized - self.assertRaises(Unauthorized, self._callFUT, context, request, - name='registered', secure=True) + iterable = self._callFUT(context, request, name='registered', + secure=True) + self.assertEqual(iterable, ()) - def test_call_view_registered_secure_permission_allows(self): + def test_call_view_registered_insecure_no_call_permissive(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -171,20 +142,17 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', True) environ = self._makeEnviron() from webob import Request request = Request(environ) directlyProvides(request, IRequest) iterable = self._callFUT(context, request, name='registered', - secure=True) + secure=False) self.assertEqual(iterable, ()) - def test_call_view_registered_insecure_permission_disallows(self): + def test_call_view_registered_insecure_with_call_permissive(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -193,18 +161,18 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) + def anotherview(context, request): + return DummyResponse('anotherview') + view.__call_permissive__ = anotherview self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', False) environ = self._makeEnviron() from webob import Request request = Request(environ) directlyProvides(request, IRequest) iterable = self._callFUT(context, request, name='registered', secure=False) - self.assertEqual(iterable, ()) + self.assertEqual(iterable, ['anotherview']) class RenderViewTests(unittest.TestCase, BaseTest): def _callFUT(self, *arg, **kw): @@ -219,7 +187,7 @@ class RenderViewTests(unittest.TestCase, BaseTest): result = self._callFUT(context, request, name='notregistered') self.assertEqual(result, None) - def test_call_view_registered_secure_permission_disallows(self): + def test_call_view_registered_secure(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -228,20 +196,16 @@ class RenderViewTests(unittest.TestCase, BaseTest): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', False) environ = self._makeEnviron() from webob import Request request = Request(environ) directlyProvides(request, IRequest) - from repoze.bfg.security import Unauthorized - self.assertRaises(Unauthorized, self._callFUT, context, request, - name='registered', secure=True) + s = self._callFUT(context, request, name='registered', secure=True) + self.assertEqual(s, '') - def test_call_view_registered_secure_permission_allows(self): + def test_call_view_registered_insecure_no_call_permissive(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -250,19 +214,16 @@ class RenderViewTests(unittest.TestCase, BaseTest): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', True) environ = self._makeEnviron() from webob import Request request = Request(environ) directlyProvides(request, IRequest) - s = self._callFUT(context, request, name='registered', secure=True) + s = self._callFUT(context, request, name='registered', secure=False) self.assertEqual(s, '') - def test_call_view_registered_insecure_permission_disallows(self): + def test_call_view_registered_insecure_with_call_permissive(self): context = DummyContext() from zope.interface import Interface from zope.interface import directlyProvides @@ -271,17 +232,17 @@ class RenderViewTests(unittest.TestCase, BaseTest): pass directlyProvides(context, IContext) response = DummyResponse() - secpol = DummySecurityPolicy() view = make_view(response) + def anotherview(context, request): + return DummyResponse('anotherview') + view.__call_permissive__ = anotherview self._registerView(view, 'registered', IContext, IRequest) - self._registerSecurityPolicy(secpol) - self._registerViewPermission('registered', False) environ = self._makeEnviron() from webob import Request request = Request(environ) directlyProvides(request, IRequest) s = self._callFUT(context, request, name='registered', secure=False) - self.assertEqual(s, '') + self.assertEqual(s, 'anotherview') class TestIsResponse(unittest.TestCase): def _callFUT(self, *arg, **kw): @@ -506,6 +467,461 @@ class TestDefaultNotFoundView(unittest.TestCase): self.assertEqual(response.status, '404 Not Found') self.failUnless('abc&123' in response.body) +class TestMultiView(unittest.TestCase): + def _getTargetClass(self): + from repoze.bfg.view import MultiView + return MultiView + + def _makeOne(self, name='name'): + return self._getTargetClass()(name) + + def test_class_implements_ISecuredView(self): + from zope.interface.verify import verifyClass + from repoze.bfg.interfaces import ISecuredView + verifyClass(ISecuredView, self._getTargetClass()) + + def test_instance_implements_ISecuredView(self): + from zope.interface.verify import verifyObject + from repoze.bfg.interfaces import ISecuredView + verifyObject(ISecuredView, self._makeOne()) + + def test_add(self): + mv = self._makeOne() + mv.add('view', 100) + self.assertEqual(mv.views, [(100, 'view')]) + mv.add('view2', 99) + self.assertEqual(mv.views, [(99, 'view2'), (100, 'view')]) + + def test_match_not_found(self): + from repoze.bfg.view import NotFound + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + self.assertRaises(NotFound, mv.match, context, request) + + def test_match_predicate_fails(self): + from repoze.bfg.view import NotFound + mv = self._makeOne() + def view(context, request): + """ """ + view.__predicated__ = lambda *arg: False + mv.views = [(100, view)] + context = DummyContext() + request = DummyRequest() + self.assertRaises(NotFound, mv.match, context, request) + + def test_match_predicate_succeeds(self): + mv = self._makeOne() + def view(context, request): + """ """ + view.__predicated__ = lambda *arg: True + mv.views = [(100, view)] + context = DummyContext() + request = DummyRequest() + result = mv.match(context, request) + self.assertEqual(result, view) + + def test_permitted_no_views(self): + from repoze.bfg.view import NotFound + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + self.assertRaises(NotFound, mv.__permitted__, context, request) + + def test_permitted_no_match_with__permitted__(self): + mv = self._makeOne() + def view(context, request): + """ """ + mv.views = [(100, view)] + context = DummyContext() + request = DummyRequest() + self.assertEqual(mv.__permitted__(None, None), True) + + def test_permitted(self): + from zope.component import getSiteManager + mv = self._makeOne() + def view(context, request): + """ """ + def permitted(context, request): + return False + view.__permitted__ = permitted + mv.views = [(100, view)] + context = DummyContext() + request = DummyRequest() + sm = getSiteManager() + result = mv.__permitted__(context, request) + self.assertEqual(result, False) + + def test__call__not_found(self): + from repoze.bfg.view import NotFound + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + self.assertRaises(NotFound, mv, context, request) + + def test___call__intermediate_not_found(self): + from repoze.bfg.view import NotFound + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + request.view_name = '' + expected_response = DummyResponse() + def view1(context, request): + raise NotFound + def view2(context, request): + return expected_response + mv.views = [(100, view1), (99, view2)] + response = mv(context, request) + self.assertEqual(response, expected_response) + + def test___call__(self): + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + request.view_name = '' + expected_response = DummyResponse() + def view(context, request): + return expected_response + mv.views = [(100, view)] + response = mv(context, request) + self.assertEqual(response, expected_response) + + def test__call_permissive__not_found(self): + from repoze.bfg.view import NotFound + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + self.assertRaises(NotFound, mv, context, request) + + def test___call_permissive_has_call_permissive(self): + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + request.view_name = '' + expected_response = DummyResponse() + def view(context, request): + """ """ + def permissive(context, request): + return expected_response + view.__call_permissive__ = permissive + mv.views = [(100, view)] + response = mv.__call_permissive__(context, request) + self.assertEqual(response, expected_response) + + def test___call_permissive_has_no_call_permissive(self): + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + request.view_name = '' + expected_response = DummyResponse() + def view(context, request): + return expected_response + mv.views = [(100, view)] + response = mv.__call_permissive__(context, request) + self.assertEqual(response, expected_response) + +class TestMapView(unittest.TestCase): + def setUp(self): + cleanUp() + + def tearDown(self): + cleanUp() + + def _callFUT(self, view, *arg, **kw): + from repoze.bfg.view import map_view + return map_view(view, *arg, **kw) + + def test_view_as_function_context_and_request(self): + def view(context, request): + return 'OK' + result = self._callFUT(view) + self.failUnless(result is view) + self.assertEqual(view(None, None), 'OK') + + def test_view_as_function_requestonly(self): + def view(request): + return 'OK' + result = self._callFUT(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_view_as_newstyle_class_context_and_request(self): + class view(object): + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = self._callFUT(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_view_as_newstyle_class_requestonly(self): + class view(object): + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = self._callFUT(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_view_as_oldstyle_class_context_and_request(self): + class view: + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = self._callFUT(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_view_as_oldstyle_class_requestonly(self): + class view: + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = self._callFUT(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_view_as_instance_context_and_request(self): + class View: + def __call__(self, context, request): + return 'OK' + view = View() + result = self._callFUT(view) + self.failUnless(result is view) + self.assertEqual(result(None, None), 'OK') + + def test_view_as_instance_requestonly(self): + class View: + def __call__(self, request): + return 'OK' + view = View() + result = self._callFUT(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') + +class TestRequestOnly(unittest.TestCase): + def _callFUT(self, arg): + from repoze.bfg.view import requestonly + return requestonly(arg) + + def test_newstyle_class_no_init(self): + class foo(object): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_newstyle_class_init_toomanyargs(self): + class foo(object): + def __init__(self, context, request): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_newstyle_class_init_onearg_named_request(self): + class foo(object): + def __init__(self, request): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_newstyle_class_init_onearg_named_somethingelse(self): + class foo(object): + def __init__(self, req): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_newstyle_class_init_defaultargs_firstname_not_request(self): + class foo(object): + def __init__(self, context, request=None): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_newstyle_class_init_defaultargs_firstname_request(self): + class foo(object): + def __init__(self, request, foo=1, bar=2): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_newstyle_class_init_noargs(self): + class foo(object): + def __init__(): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_oldstyle_class_no_init(self): + class foo: + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_oldstyle_class_init_toomanyargs(self): + class foo: + def __init__(self, context, request): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_oldstyle_class_init_onearg_named_request(self): + class foo: + def __init__(self, request): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_oldstyle_class_init_onearg_named_somethingelse(self): + class foo: + def __init__(self, req): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_oldstyle_class_init_defaultargs_firstname_not_request(self): + class foo: + def __init__(self, context, request=None): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_oldstyle_class_init_defaultargs_firstname_request(self): + class foo: + def __init__(self, request, foo=1, bar=2): + """ """ + self.assertTrue(self._callFUT(foo), True) + + def test_oldstyle_class_init_noargs(self): + class foo: + def __init__(): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_function_toomanyargs(self): + def foo(context, request): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_function_onearg_named_request(self): + def foo(request): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_function_onearg_named_somethingelse(self): + def foo(req): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_function_defaultargs_firstname_not_request(self): + def foo(context, request=None): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_function_defaultargs_firstname_request(self): + def foo(request, foo=1, bar=2): + """ """ + self.assertTrue(self._callFUT(foo), True) + + def test_instance_toomanyargs(self): + class Foo: + def __call__(self, context, request): + """ """ + foo = Foo() + self.assertFalse(self._callFUT(foo)) + + def test_instance_defaultargs_onearg_named_request(self): + class Foo: + def __call__(self, request): + """ """ + foo = Foo() + self.assertTrue(self._callFUT(foo)) + + def test_instance_defaultargs_onearg_named_somethingelse(self): + class Foo: + def __call__(self, req): + """ """ + foo = Foo() + self.assertTrue(self._callFUT(foo)) + + def test_instance_defaultargs_firstname_not_request(self): + class Foo: + def __call__(self, context, request=None): + """ """ + foo = Foo() + self.assertFalse(self._callFUT(foo)) + + def test_instance_defaultargs_firstname_request(self): + class Foo: + def __call__(self, request, foo=1, bar=2): + """ """ + foo = Foo() + self.assertTrue(self._callFUT(foo), True) + + def test_instance_nocall(self): + class Foo: pass + foo = Foo() + self.assertFalse(self._callFUT(foo)) + +class TestDecorateView(unittest.TestCase): + def _callFUT(self, wrapped, original): + from repoze.bfg.view import decorate_view + return decorate_view(wrapped, original) + + def test_it_same(self): + def view(context, request): + """ """ + result = self._callFUT(view, view) + self.assertEqual(result, False) + + def test_it_different(self): + class DummyView1: + """ 1 """ + __name__ = '1' + __module__ = '1' + def __call__(self, context, request): + """ """ + def __call_permissive__(self, context, reuqest): + """ """ + def __predicated__(self, context, reuqest): + """ """ + def __permitted__(self, context, request): + """ """ + class DummyView2: + """ 2 """ + __name__ = '2' + __module__ = '2' + def __call__(self, context, request): + """ """ + def __call_permissive__(self, context, reuqest): + """ """ + def __predicated__(self, context, reuqest): + """ """ + def __permitted__(self, context, request): + """ """ + view1 = DummyView1() + view2 = DummyView2() + result = self._callFUT(view1, view2) + self.assertEqual(result, True) + self.failUnless(view1.__doc__ is view2.__doc__) + self.failUnless(view1.__module__ is view2.__module__) + self.failUnless(view1.__name__ is view2.__name__) + self.failUnless(view1.__call_permissive__.im_func is + view2.__call_permissive__.im_func) + self.failUnless(view1.__permitted__.im_func is + view2.__permitted__.im_func) + self.failUnless(view1.__predicated__.im_func is + view2.__predicated__.im_func) class DummyContext: pass @@ -531,8 +947,9 @@ def make_view(response): class DummyResponse: status = '200 OK' headerlist = () - app_iter = () - -class DummySecurityPolicy: - pass - + def __init__(self, body=None): + if body is None: + self.app_iter = () + else: + self.app_iter = [body] + -- cgit v1.2.3