From e06153d2a851513c435b9f7dc2a5d8f3a1191405 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 16 Nov 2009 22:05:17 +0000 Subject: Failing one test. --- repoze/bfg/tests/test_registry.py | 373 +++++++++- repoze/bfg/tests/test_view.py | 1393 ++++++++++++++----------------------- 2 files changed, 901 insertions(+), 865 deletions(-) (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_registry.py b/repoze/bfg/tests/test_registry.py index 3eada7b1c..11f5cbf3a 100644 --- a/repoze/bfg/tests/test_registry.py +++ b/repoze/bfg/tests/test_registry.py @@ -61,6 +61,355 @@ class TestRegistry(unittest.TestCase): self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) self.assertEqual(overrides.package, package) + def _registerRenderer(self, reg, name='.txt'): + from repoze.bfg.interfaces import IRendererFactory + from repoze.bfg.interfaces import ITemplateRenderer + from zope.interface import implements + class Renderer: + implements(ITemplateRenderer) + def __init__(self, path): + pass + def __call__(self, *arg): + return 'Hello!' + reg.registerUtility(Renderer, IRendererFactory, name=name) + + def test_map_view_as_function_context_and_request(self): + def view(context, request): + return 'OK' + reg = self._makeOne() + result = reg.map_view(view) + self.failUnless(result is view) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_function_with_attr(self): + def view(context, request): + """ """ + reg = self._makeOne() + result = reg.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): + reg = self._makeOne() + self._registerRenderer(reg) + def view(context, request): + """ """ + result = reg.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): + reg = self._makeOne() + def view(request): + return 'OK' + result = reg.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): + reg = self._makeOne() + def view(request): + """ """ + result = reg.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): + reg = self._makeOne() + class view(object): + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = reg.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): + reg = self._makeOne() + class view(object): + def __init__(self, context, request): + pass + def index(self): + return 'OK' + result = reg.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( + self): + reg = self._makeOne() + self._registerRenderer(reg) + class view(object): + def __init__(self, context, request): + pass + def index(self): + return {'a':'1'} + result = reg.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_as_newstyle_class_requestonly(self): + reg = self._makeOne() + class view(object): + def __init__(self, request): + pass + def __call__(self): + return 'OK' + result = reg.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): + reg = self._makeOne() + class view(object): + def __init__(self, request): + pass + def index(self): + return 'OK' + result = reg.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(self): + reg = self._makeOne() + self._registerRenderer(reg) + class view(object): + def __init__(self, request): + pass + def index(self): + return {'a':'1'} + result = reg.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_as_oldstyle_class_context_and_request(self): + reg = self._makeOne() + class view: + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = reg.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): + reg = self._makeOne() + class view: + def __init__(self, context, request): + pass + def index(self): + return 'OK' + result = reg.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( + self): + reg = self._makeOne() + self._registerRenderer(reg) + class view: + def __init__(self, context, request): + pass + def index(self): + return {'a':'1'} + result = reg.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_as_oldstyle_class_requestonly(self): + reg = self._makeOne() + class view: + def __init__(self, request): + pass + def __call__(self): + return 'OK' + result = reg.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): + reg = self._makeOne() + class view: + def __init__(self, request): + pass + def index(self): + return 'OK' + result = reg.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): + reg = self._makeOne() + self._registerRenderer(reg) + class view: + def __init__(self, request): + pass + def index(self): + return {'a':'1'} + result = reg.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_as_instance_context_and_request(self): + reg = self._makeOne() + class View: + def __call__(self, context, request): + return 'OK' + view = View() + result = reg.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): + reg = self._makeOne() + class View: + def index(self, context, request): + return 'OK' + view = View() + result = reg.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): + reg = self._makeOne() + self._registerRenderer(reg) + class View: + def index(self, context, request): + return {'a':'1'} + view = View() + result = reg.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): + reg = self._makeOne() + class View: + def __call__(self, request): + return 'OK' + view = View() + result = reg.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): + reg = self._makeOne() + class View: + def index(self, request): + return 'OK' + view = View() + result = reg.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): + reg = self._makeOne() + self._registerRenderer(reg) + class View: + def index(self, request): + return {'a':'1'} + view = View() + result = reg.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.failUnless('instance' in result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_rendereronly(self): + reg = self._makeOne() + self._registerRenderer(reg) + def view(context, request): + return {'a':'1'} + result = reg.map_view( + view, + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_defaultrendereronly(self): + reg = self._makeOne() + self._registerRenderer(reg, name='') + def view(context, request): + return {'a':'1'} + result = reg.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!') + class TestBFGViewGrokker(unittest.TestCase): def setUp(self): cleanUp() @@ -133,7 +482,6 @@ class TestDefaultRootFactory(unittest.TestCase): self.assertEqual(root.a, 1) self.assertEqual(root.b, 2) - class DummyModule: __path__ = "foo" __name__ = "dummy" @@ -157,3 +505,26 @@ class DummyOverrides: def insert(self, path, package, prefix): self.inserted.append((path, package, prefix)) + +class DummyRequest: + def __init__(self, environ=None): + if environ is None: + environ = {} + self.environ = environ + + def get_response(self, application): + return application + + def copy(self): + self.copied = True + return self + +class DummyResponse: + status = '200 OK' + headerlist = () + def __init__(self, body=None): + if body is None: + self.app_iter = () + else: + self.app_iter = [body] + diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py index 80179e247..807dbe85a 100644 --- a/repoze/bfg/tests/test_view.py +++ b/repoze/bfg/tests/test_view.py @@ -526,160 +526,88 @@ class AppendSlashNotFoundView(unittest.TestCase): self.assertEqual(response.status, '302 Found') self.assertEqual(response.location, '/abc/') -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.exceptions import NotFound - mv = self._makeOne() - context = DummyContext() - request = DummyRequest() - self.assertRaises(NotFound, mv.match, context, request) +class Test_rendered_response(unittest.TestCase): + def setUp(self): + cleanUp() - def test_match_predicate_fails(self): - from repoze.bfg.exceptions 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 tearDown(self): + cleanUp() - 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 _callFUT(self, renderer, response, view=None, + context=None, request=None, renderer_name=None): + from repoze.bfg.view import rendered_response + if request is None: + request = DummyRequest() + return rendered_response(renderer, response, view, + context, request, renderer_name) - def test_permitted_no_views(self): - from repoze.bfg.exceptions import NotFound - mv = self._makeOne() - context = DummyContext() - request = DummyRequest() - self.assertRaises(NotFound, mv.__permitted__, context, request) + def _makeRenderer(self): + def renderer(*arg): + return 'Hello!' + return renderer - 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_is_response(self): + renderer = self._makeRenderer() + response = DummyResponse() + result = self._callFUT(renderer, response) + self.assertEqual(result, response) - def test__call__not_found(self): - from repoze.bfg.exceptions import NotFound - mv = self._makeOne() - context = DummyContext() - request = DummyRequest() - self.assertRaises(NotFound, mv, context, request) + def test_calls_renderer(self): + renderer = self._makeRenderer() + response = {'a':'1'} + result = self._callFUT(renderer, response) + self.assertEqual(result.body, 'Hello!') - def test___call__intermediate_not_found(self): - from repoze.bfg.exceptions import NotFound - mv = self._makeOne() - context = DummyContext() + def test_with_content_type(self): + renderer = self._makeRenderer() + response = {'a':'1'} 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) + attrs = {'response_content_type':'text/nonsense'} + request.__dict__.update(attrs) + result = self._callFUT(renderer, response, request=request) + self.assertEqual(result.content_type, 'text/nonsense') - def test___call__(self): - mv = self._makeOne() - context = DummyContext() + def test_with_headerlist(self): + renderer = self._makeRenderer() + response = {'a':'1'} 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) + attrs = {'response_headerlist':[('a', '1'), ('b', '2')]} + request.__dict__.update(attrs) + result = self._callFUT(renderer, response, request=request) + self.assertEqual(result.headerlist, + [('Content-Type', 'text/html; charset=UTF-8'), + ('Content-Length', '6'), + ('a', '1'), + ('b', '2')]) - def test__call_permissive__not_found(self): - from repoze.bfg.exceptions import NotFound - mv = self._makeOne() - context = DummyContext() + def test_with_status(self): + renderer = self._makeRenderer() + response = {'a':'1'} request = DummyRequest() - self.assertRaises(NotFound, mv, context, request) + attrs = {'response_status':'406 You Lose'} + request.__dict__.update(attrs) + result = self._callFUT(renderer, response, request=request) + self.assertEqual(result.status, '406 You Lose') - def test___call_permissive_has_call_permissive(self): - mv = self._makeOne() - context = DummyContext() + def test_with_charset(self): + renderer = self._makeRenderer() + response = {'a':'1'} 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) + attrs = {'response_charset':'UTF-16'} + request.__dict__.update(attrs) + result = self._callFUT(renderer, response, request=request) + self.assertEqual(result.charset, 'UTF-16') - def test___call_permissive_has_no_call_permissive(self): - mv = self._makeOne() - context = DummyContext() + def test_with_cache_for(self): + renderer = self._makeRenderer() + response = {'a':'1'} 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) + attrs = {'response_cache_for':100} + request.__dict__.update(attrs) + result = self._callFUT(renderer, response, request=request) + self.assertEqual(result.cache_control.max_age, 100) -class Test_map_view(unittest.TestCase): +class TestDeriveView(unittest.TestCase): def setUp(self): cleanUp() @@ -687,45 +615,39 @@ class Test_map_view(unittest.TestCase): cleanUp() def _callFUT(self, view, *arg, **kw): - from repoze.bfg.view import map_view - return map_view(view, *arg, **kw) + from repoze.bfg.view import derive_view + return derive_view(view, *arg, **kw) - def _registerRenderer(self, name='.txt'): - from repoze.bfg.interfaces import IRendererFactory - from repoze.bfg.interfaces import ITemplateRenderer - from zope.interface import implements + def _registerLogger(self): + from repoze.bfg.interfaces import ILogger + from zope.component import getSiteManager + logger = DummyLogger() + sm = getSiteManager() + sm.registerUtility(logger, ILogger, 'repoze.bfg.debug') + return logger + + def _registerSettings(self, **settings): + from repoze.bfg.interfaces import ISettings from zope.component import getSiteManager - class Renderer: - implements(ITemplateRenderer) - def __init__(self, path): - pass - def __call__(self, *arg): - return 'Hello!' sm = getSiteManager() - sm.registerUtility(Renderer, IRendererFactory, name=name) + sm.registerUtility(settings, ISettings) + def _registerSecurityPolicy(self, permissive): + from repoze.bfg.interfaces import IAuthenticationPolicy + from repoze.bfg.interfaces import IAuthorizationPolicy + from zope.component import getSiteManager + policy = DummySecurityPolicy(permissive) + sm = getSiteManager() + sm.registerUtility(policy, IAuthenticationPolicy) + sm.registerUtility(policy, IAuthorizationPolicy) + 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(result(None, None), 'OK') - - def test_view_as_function_with_attr(self): - def view(context, request): - """ """ - result = self._callFUT(view, attr='__name__') - self.failIf(result is view) - self.assertRaises(TypeError, result, None, None) - - def test_view_as_function_with_attr_and_renderer(self): - self._registerRenderer() - def view(context, request): - """ """ - result = self._callFUT(view, attr='__name__', - renderer_name='fixtures/minimal.txt') - self.failIf(result is view) - self.assertRaises(TypeError, result, None, None) + self.failIf(hasattr(result, '__call_permissive__')) + self.assertEqual(view(None, None), 'OK') def test_view_as_function_requestonly(self): def view(request): @@ -735,18 +657,9 @@ class Test_map_view(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test_view_as_function_requestonly_with_attr(self): - def view(request): - """ """ - result = self._callFUT(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_view_as_newstyle_class_context_and_request(self): class view(object): def __init__(self, context, request): @@ -758,84 +671,25 @@ class Test_map_view(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - - def test_view_as_newstyle_class_context_and_request_with_attr(self): + + def test_view_as_newstyle_class_requestonly(self): class view(object): def __init__(self, context, request): pass - def index(self): + def __call__(self): return 'OK' - result = self._callFUT(view, attr='index') + 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.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test_view_as_newstyle_class_context_and_request_with_attr_and_renderer( - self): - self._registerRenderer() - class view(object): - def __init__(self, context, request): - pass - def index(self): - return {'a':'1'} - result = self._callFUT( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_view_as_newstyle_class_requestonly(self): - class view(object): - def __init__(self, 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_with_attr(self): - class view(object): - def __init__(self, request): - pass - def index(self): - return 'OK' - result = self._callFUT(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_view_as_newstyle_class_requestonly_with_attr_and_renderer(self): - self._registerRenderer() - class view(object): - def __init__(self, request): - pass - def index(self): - return {'a':'1'} - result = self._callFUT( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_view_as_oldstyle_class_context_and_request(self): - class view: + def test_view_as_oldstyle_class_context_and_request(self): + class view: def __init__(self, context, request): pass def __call__(self): @@ -845,42 +699,12 @@ class Test_map_view(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - - def test_view_as_oldstyle_class_context_and_request_with_attr(self): - class view: - def __init__(self, context, request): - pass - def index(self): - return 'OK' - result = self._callFUT(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_view_as_oldstyle_class_context_and_request_with_attr_and_renderer( - self): - self._registerRenderer() - class view: - def __init__(self, context, request): - pass - def index(self): - return {'a':'1'} - result = self._callFUT( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - + def test_view_as_oldstyle_class_requestonly(self): class view: - def __init__(self, request): + def __init__(self, context, request): pass def __call__(self): return 'OK' @@ -889,38 +713,9 @@ class Test_map_view(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test_view_as_oldstyle_class_requestonly_with_attr(self): - class view: - def __init__(self, request): - pass - def index(self): - return 'OK' - result = self._callFUT(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_view_as_oldstyle_class_requestonly_with_attr_and_renderer(self): - self._registerRenderer() - class view: - def __init__(self, request): - pass - def index(self): - return {'a':'1'} - result = self._callFUT( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - def test_view_as_instance_context_and_request(self): class View: def __call__(self, context, request): @@ -928,30 +723,9 @@ class Test_map_view(unittest.TestCase): view = View() result = self._callFUT(view) self.failUnless(result is view) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test_view_as_instance_context_and_request_and_attr(self): - class View: - def index(self, context, request): - return 'OK' - view = View() - result = self._callFUT(view, attr='index') - self.failIf(result is view) - self.assertEqual(result(None, None), 'OK') - - def test_view_as_instance_context_and_request_attr_and_renderer(self): - self._registerRenderer() - class View: - def index(self, context, request): - return {'a':'1'} - view = View() - result = self._callFUT( - 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_view_as_instance_requestonly(self): class View: def __call__(self, request): @@ -962,211 +736,190 @@ class Test_map_view(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.failUnless('instance' in result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') - def test_view_as_instance_requestonly_with_attr(self): - class View: - def index(self, request): - return 'OK' - view = View() - result = self._callFUT(view, attr='index') - self.failIf(result is view) + def test_view_with_debug_authorization_no_authpol(self): + def view(context, request): + return 'OK' + self._registerSettings(debug_authorization=True, reload_templates=True) + logger = self._registerLogger() + result = self._callFUT(view, permission='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') + self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) + request = DummyRequest() + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): Allowed " + "(no authorization policy in use)") - def test_view_as_instance_requestonly_with_attr_and_renderer(self): - self._registerRenderer() - class View: - def index(self, request): - return {'a':'1'} - view = View() - result = self._callFUT( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) + def test_view_with_debug_authorization_no_permission(self): + def view(context, request): + return 'OK' + self._registerSettings(debug_authorization=True, reload_templates=True) + self._registerSecurityPolicy(True) + logger = self._registerLogger() + result = self._callFUT(view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) - self.failUnless('instance' in result.__name__) + self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): Allowed (" + "no permission registered)") - def test_view_rendereronly(self): - self._registerRenderer() + def test_view_with_debug_authorization_permission_authpol_permitted(self): def view(context, request): - return {'a':'1'} - result = self._callFUT( - view, - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) + return 'OK' + self._registerSettings(debug_authorization=True, reload_templates=True) + logger = self._registerLogger() + self._registerSecurityPolicy(True) + result = self._callFUT(view, permission='view') self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result.__call_permissive__, view) request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_view_defaultrendereronly(self): - self._registerRenderer(name='') + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): True") + + def test_view_with_debug_authorization_permission_authpol_denied(self): + from repoze.bfg.exceptions import Forbidden def view(context, request): - return {'a':'1'} - result = self._callFUT(view) - self.failIf(result is view) + """ """ + self._registerSettings(debug_authorization=True, reload_templates=True) + logger = self._registerLogger() + self._registerSecurityPolicy(False) + result = self._callFUT(view, permission='view') self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result.__call_permissive__, view) request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') + request.view_name = 'view_name' + request.url = 'url' + self.assertRaises(Forbidden, result, None, request) + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): False") -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): + def test_view_with_debug_authorization_permission_authpol_denied2(self): + def view(context, request): """ """ - 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)) + self._registerSettings(debug_authorization=True, reload_templates=True) + logger = self._registerLogger() + self._registerSecurityPolicy(False) + result = self._callFUT(view, permission='view') + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + request.view_name = 'view_name' + request.url = 'url' + permitted = result.__permitted__(None, None) + self.assertEqual(permitted, False) - def test_newstyle_class_init_noargs(self): - class foo(object): - def __init__(): - """ """ - self.assertFalse(self._callFUT(foo)) + def test_view_with_predicates_all(self): + def view(context, request): + return '123' + predicates = [] + def predicate1(context, request): + predicates.append(True) + return True + def predicate2(context, request): + predicates.append(True) + return True + result = self._callFUT(view, predicates=[predicate1, predicate2]) + request = DummyRequest() + request.method = 'POST' + next = result(None, None) + self.assertEqual(next, '123') + self.assertEqual(predicates, [True, True]) - def test_oldstyle_class_no_init(self): - class foo: + def test_view_with_predicates_notall(self): + from repoze.bfg.exceptions import NotFound + def view(context, request): """ """ - 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)) + predicates = [] + def predicate1(context, request): + predicates.append(True) + return True + def predicate2(context, request): + predicates.append(True) + return False + result = self._callFUT(view, predicates=[predicate1, predicate2]) + request = DummyRequest() + request.method = 'POST' + self.assertRaises(NotFound, result, None, None) + self.assertEqual(predicates, [True, True]) - def test_function_defaultargs_firstname_request(self): - def foo(request, foo=1, bar=2): + def test_view_with_predicates_checker(self): + def view(context, request): """ """ - 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)) + predicates = [] + def predicate1(context, request): + predicates.append(True) + return True + def predicate2(context, request): + predicates.append(True) + return True + result = self._callFUT(view, predicates=[predicate1, predicate2]) + request = DummyRequest() + request.method = 'POST' + next = result.__predicated__(None, None) + self.assertEqual(next, True) + self.assertEqual(predicates, [True, True]) - 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_view_with_wrapper_viewname(self): + from webob import Response + from zope.component import getSiteManager + from repoze.bfg.interfaces import IView + inner_response = Response('OK') + def inner_view(context, request): + return inner_response + def outer_view(context, request): + self.assertEqual(request.wrapped_response, inner_response) + self.assertEqual(request.wrapped_body, inner_response.body) + self.assertEqual(request.wrapped_view, inner_view) + return Response('outer ' + request.wrapped_body) + sm = getSiteManager() + sm.registerAdapter(outer_view, (None, None), IView, 'owrap') + result = self._callFUT(inner_view, viewname='inner', + wrapper_viewname='owrap') + self.failIf(result is inner_view) + self.assertEqual(inner_view.__module__, result.__module__) + self.assertEqual(inner_view.__doc__, result.__doc__) + request = DummyRequest() + response = result(None, request) + self.assertEqual(response.body, 'outer OK') - def test_instance_nocall(self): - class Foo: pass - foo = Foo() - self.assertFalse(self._callFUT(foo)) + def test_view_with_wrapper_viewname_notfound(self): + from webob import Response + inner_response = Response('OK') + def inner_view(context, request): + return inner_response + request = DummyRequest() + wrapped = self._callFUT( + inner_view, viewname='inner', wrapper_viewname='owrap') + result = self.assertRaises(ValueError, wrapped, None, request) class TestDecorateView(unittest.TestCase): def _callFUT(self, wrapped, original): @@ -1218,400 +971,312 @@ class TestDecorateView(unittest.TestCase): self.failUnless(view1.__predicated__.im_func is view2.__predicated__.im_func) -class Test_rendered_response(unittest.TestCase): - def setUp(self): - cleanUp() - - def tearDown(self): - cleanUp() - - def _callFUT(self, renderer, response, view=None, - context=None, request=None, renderer_name=None): - from repoze.bfg.view import rendered_response - if request is None: - request = DummyRequest() - return rendered_response(renderer, response, view, - context, request, renderer_name) +class TestMultiView(unittest.TestCase): + def _getTargetClass(self): + from repoze.bfg.view import MultiView + return MultiView - def _makeRenderer(self): - def renderer(*arg): - return 'Hello!' - return renderer + 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_is_response(self): - renderer = self._makeRenderer() - response = DummyResponse() - result = self._callFUT(renderer, response) - self.assertEqual(result, response) + def test_instance_implements_ISecuredView(self): + from zope.interface.verify import verifyObject + from repoze.bfg.interfaces import ISecuredView + verifyObject(ISecuredView, self._makeOne()) - def test_calls_renderer(self): - renderer = self._makeRenderer() - response = {'a':'1'} - result = self._callFUT(renderer, response) - self.assertEqual(result.body, 'Hello!') + 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_with_content_type(self): - renderer = self._makeRenderer() - response = {'a':'1'} + def test_match_not_found(self): + from repoze.bfg.exceptions import NotFound + mv = self._makeOne() + context = DummyContext() request = DummyRequest() - attrs = {'response_content_type':'text/nonsense'} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.content_type, 'text/nonsense') + self.assertRaises(NotFound, mv.match, context, request) - def test_with_headerlist(self): - renderer = self._makeRenderer() - response = {'a':'1'} + def test_match_predicate_fails(self): + from repoze.bfg.exceptions import NotFound + mv = self._makeOne() + def view(context, request): + """ """ + view.__predicated__ = lambda *arg: False + mv.views = [(100, view)] + context = DummyContext() request = DummyRequest() - attrs = {'response_headerlist':[('a', '1'), ('b', '2')]} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.headerlist, - [('Content-Type', 'text/html; charset=UTF-8'), - ('Content-Length', '6'), - ('a', '1'), - ('b', '2')]) + self.assertRaises(NotFound, mv.match, context, request) - def test_with_status(self): - renderer = self._makeRenderer() - response = {'a':'1'} + 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() - attrs = {'response_status':'406 You Lose'} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.status, '406 You Lose') + result = mv.match(context, request) + self.assertEqual(result, view) - def test_with_charset(self): - renderer = self._makeRenderer() - response = {'a':'1'} + def test_permitted_no_views(self): + from repoze.bfg.exceptions import NotFound + mv = self._makeOne() + context = DummyContext() request = DummyRequest() - attrs = {'response_charset':'UTF-16'} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.charset, 'UTF-16') + self.assertRaises(NotFound, mv.__permitted__, context, request) - def test_with_cache_for(self): - renderer = self._makeRenderer() - response = {'a':'1'} + def test_permitted_no_match_with__permitted__(self): + mv = self._makeOne() + def view(context, request): + """ """ + mv.views = [(100, view)] + context = DummyContext() request = DummyRequest() - attrs = {'response_cache_for':100} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.cache_control.max_age, 100) - -class TestDeriveView(unittest.TestCase): - def setUp(self): - cleanUp() - - def tearDown(self): - cleanUp() + self.assertEqual(mv.__permitted__(None, None), True) - def _callFUT(self, view, *arg, **kw): - from repoze.bfg.view import derive_view - return derive_view(view, *arg, **kw) - - def _registerLogger(self): - from repoze.bfg.interfaces import ILogger + def test_permitted(self): from zope.component import getSiteManager - logger = DummyLogger() + 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() - sm.registerUtility(logger, ILogger, 'repoze.bfg.debug') - return logger + result = mv.__permitted__(context, request) + self.assertEqual(result, False) - def _registerSettings(self, **settings): - from repoze.bfg.interfaces import ISettings - from zope.component import getSiteManager - sm = getSiteManager() - sm.registerUtility(settings, ISettings) + def test__call__not_found(self): + from repoze.bfg.exceptions import NotFound + mv = self._makeOne() + context = DummyContext() + request = DummyRequest() + self.assertRaises(NotFound, mv, context, request) - def _registerSecurityPolicy(self, permissive): - from repoze.bfg.interfaces import IAuthenticationPolicy - from repoze.bfg.interfaces import IAuthorizationPolicy - from zope.component import getSiteManager - policy = DummySecurityPolicy(permissive) - sm = getSiteManager() - sm.registerUtility(policy, IAuthenticationPolicy) - sm.registerUtility(policy, IAuthorizationPolicy) - - def test_view_as_function_context_and_request(self): + def test___call__intermediate_not_found(self): + from repoze.bfg.exceptions 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 'OK' - result = self._callFUT(view) - self.failUnless(result is view) - self.failIf(hasattr(result, '__call_permissive__')) - 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.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(result(None, None), 'OK') + return expected_response + mv.views = [(100, view)] + response = mv(context, request) + self.assertEqual(response, expected_response) - def test_view_as_newstyle_class_context_and_request(self): - class view(object): + def test__call_permissive__not_found(self): + from repoze.bfg.exceptions 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 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): - 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.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(result(None, None), 'OK') + """ """ + self.assertFalse(self._callFUT(foo)) - 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.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(result(None, None), 'OK') + def test_newstyle_class_init_onearg_named_request(self): + class foo(object): + def __init__(self, request): + """ """ + self.assertTrue(self._callFUT(foo)) - def test_view_as_oldstyle_class_context_and_request(self): - class view: + 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): - 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.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(result(None, None), 'OK') + """ """ + self.assertFalse(self._callFUT(foo)) - 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.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(result(None, None), 'OK') + def test_oldstyle_class_init_onearg_named_request(self): + class foo: + def __init__(self, request): + """ """ + self.assertTrue(self._callFUT(foo)) - 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.failIf(hasattr(result, '__call_permissive__')) - 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.failIf(hasattr(result, '__call_permissive__')) - self.assertEqual(result(None, None), 'OK') + def test_oldstyle_class_init_onearg_named_somethingelse(self): + class foo: + def __init__(self, req): + """ """ + self.assertTrue(self._callFUT(foo)) - def test_view_with_debug_authorization_no_authpol(self): - def view(context, request): - return 'OK' - self._registerSettings(debug_authorization=True, reload_templates=True) - logger = self._registerLogger() - result = self._callFUT(view, permission='view') - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) - request = DummyRequest() - request.view_name = 'view_name' - request.url = 'url' - self.assertEqual(result(None, request), 'OK') - self.assertEqual(len(logger.messages), 1) - self.assertEqual(logger.messages[0], - "debug_authorization of url url (view name " - "'view_name' against context None): Allowed " - "(no authorization policy in use)") + def test_oldstyle_class_init_defaultargs_firstname_not_request(self): + class foo: + def __init__(self, context, request=None): + """ """ + self.assertFalse(self._callFUT(foo)) - def test_view_with_debug_authorization_no_permission(self): - def view(context, request): - return 'OK' - self._registerSettings(debug_authorization=True, reload_templates=True) - self._registerSecurityPolicy(True) - logger = self._registerLogger() - result = self._callFUT(view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) - request = DummyRequest() - request.view_name = 'view_name' - request.url = 'url' - self.assertEqual(result(None, request), 'OK') - self.assertEqual(len(logger.messages), 1) - self.assertEqual(logger.messages[0], - "debug_authorization of url url (view name " - "'view_name' against context None): Allowed (" - "no permission registered)") + def test_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_view_with_debug_authorization_permission_authpol_permitted(self): - def view(context, request): - return 'OK' - self._registerSettings(debug_authorization=True, reload_templates=True) - logger = self._registerLogger() - self._registerSecurityPolicy(True) - result = self._callFUT(view, permission='view') - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result.__call_permissive__, view) - request = DummyRequest() - request.view_name = 'view_name' - request.url = 'url' - self.assertEqual(result(None, request), 'OK') - self.assertEqual(len(logger.messages), 1) - self.assertEqual(logger.messages[0], - "debug_authorization of url url (view name " - "'view_name' against context None): True") + def test_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_view_with_debug_authorization_permission_authpol_denied(self): - from repoze.bfg.exceptions import Forbidden - def view(context, request): + def test_function_onearg_named_request(self): + def foo(request): """ """ - self._registerSettings(debug_authorization=True, reload_templates=True) - logger = self._registerLogger() - self._registerSecurityPolicy(False) - result = self._callFUT(view, permission='view') - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result.__call_permissive__, view) - request = DummyRequest() - request.view_name = 'view_name' - request.url = 'url' - self.assertRaises(Forbidden, result, None, request) - self.assertEqual(len(logger.messages), 1) - self.assertEqual(logger.messages[0], - "debug_authorization of url url (view name " - "'view_name' against context None): False") + self.assertTrue(self._callFUT(foo)) - def test_view_with_debug_authorization_permission_authpol_denied2(self): - def view(context, request): + def test_function_onearg_named_somethingelse(self): + def foo(req): """ """ - self._registerSettings(debug_authorization=True, reload_templates=True) - logger = self._registerLogger() - self._registerSecurityPolicy(False) - result = self._callFUT(view, permission='view') - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - request.view_name = 'view_name' - request.url = 'url' - permitted = result.__permitted__(None, None) - self.assertEqual(permitted, False) - - def test_view_with_predicates_all(self): - def view(context, request): - return '123' - predicates = [] - def predicate1(context, request): - predicates.append(True) - return True - def predicate2(context, request): - predicates.append(True) - return True - result = self._callFUT(view, predicates=[predicate1, predicate2]) - request = DummyRequest() - request.method = 'POST' - next = result(None, None) - self.assertEqual(next, '123') - self.assertEqual(predicates, [True, True]) + self.assertTrue(self._callFUT(foo)) - def test_view_with_predicates_notall(self): - from repoze.bfg.exceptions import NotFound - def view(context, request): + def test_function_defaultargs_firstname_not_request(self): + def foo(context, request=None): """ """ - predicates = [] - def predicate1(context, request): - predicates.append(True) - return True - def predicate2(context, request): - predicates.append(True) - return False - result = self._callFUT(view, predicates=[predicate1, predicate2]) - request = DummyRequest() - request.method = 'POST' - self.assertRaises(NotFound, result, None, None) - self.assertEqual(predicates, [True, True]) + self.assertFalse(self._callFUT(foo)) - def test_view_with_predicates_checker(self): - def view(context, request): + def test_function_defaultargs_firstname_request(self): + def foo(request, foo=1, bar=2): """ """ - predicates = [] - def predicate1(context, request): - predicates.append(True) - return True - def predicate2(context, request): - predicates.append(True) - return True - result = self._callFUT(view, predicates=[predicate1, predicate2]) - request = DummyRequest() - request.method = 'POST' - next = result.__predicated__(None, None) - self.assertEqual(next, True) - self.assertEqual(predicates, [True, True]) + 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)) - def test_view_with_wrapper_viewname(self): - from webob import Response - from zope.component import getSiteManager - from repoze.bfg.interfaces import IView - inner_response = Response('OK') - def inner_view(context, request): - return inner_response - def outer_view(context, request): - self.assertEqual(request.wrapped_response, inner_response) - self.assertEqual(request.wrapped_body, inner_response.body) - self.assertEqual(request.wrapped_view, inner_view) - return Response('outer ' + request.wrapped_body) - sm = getSiteManager() - sm.registerAdapter(outer_view, (None, None), IView, 'owrap') - result = self._callFUT(inner_view, viewname='inner', - wrapper_viewname='owrap') - self.failIf(result is inner_view) - self.assertEqual(inner_view.__module__, result.__module__) - self.assertEqual(inner_view.__doc__, result.__doc__) - request = DummyRequest() - response = result(None, request) - self.assertEqual(response.body, 'outer OK') - def test_view_with_wrapper_viewname_notfound(self): - from webob import Response - inner_response = Response('OK') - def inner_view(context, request): - return inner_response - request = DummyRequest() - wrapped = self._callFUT( - inner_view, viewname='inner', wrapper_viewname='owrap') - result = self.assertRaises(ValueError, wrapped, None, request) class DummyContext: pass -- cgit v1.2.3