From a32d2a29df8948694efc78e2d30e7059f80deff7 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Thu, 19 Nov 2009 11:26:23 +0000 Subject: - The ``repoze.bfg.view.rendered_response`` function has been moved to ``repoze.bfg.configuration.rendered_response``. - The ``repoze.bfg.view.decorate_view`` function has been moved to ``repoze.bfg.configuration.decorate_view``. - The ``repoze.bfg.view.MultiView`` class has been moved to ``repoze.bfg.configuration.MultiView``. - Fix argument ordering bug in r.b.configuration.Configurator.resource. --- repoze/bfg/tests/test_configuration.py | 460 ++++++++++++++++++++++++++++++++- 1 file changed, 447 insertions(+), 13 deletions(-) (limited to 'repoze/bfg/tests/test_configuration.py') diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py index a1f60a91f..d2a9ca75f 100644 --- a/repoze/bfg/tests/test_configuration.py +++ b/repoze/bfg/tests/test_configuration.py @@ -1154,7 +1154,6 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(result(None, request).body, 'Hello!') def test_default_config_fixtureapp_default_filename_withpackage(self): - manager = DummyRegistryManager() from repoze.bfg.tests import fixtureapp rootfactory = DummyRootFactory(None) registry = self._callDefaultConfiguration(rootfactory, fixtureapp) @@ -1220,7 +1219,6 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(settings.mysetting, True) def test_declarative_registrations(self): - manager = DummyRegistryManager() settings = {'reload_templates':True, 'debug_authorization':True} from repoze.bfg.tests import fixtureapp @@ -1313,19 +1311,450 @@ class TestBFGViewGrokker(unittest.TestCase): result = grokker.grok('name', obj) self.assertEqual(result, False) -class DummyRequest: - pass +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.configuration import rendered_response + if request is None: + request = DummyRequest() + return rendered_response(renderer, response, view, + context, request, renderer_name) + + def _makeRenderer(self): + def renderer(*arg): + return 'Hello!' + return renderer + + def test_is_response(self): + renderer = self._makeRenderer() + response = DummyResponse() + result = self._callFUT(renderer, response) + self.assertEqual(result, response) + + def test_calls_renderer(self): + renderer = self._makeRenderer() + response = {'a':'1'} + result = self._callFUT(renderer, response) + self.assertEqual(result.body, 'Hello!') + + def test_with_content_type(self): + renderer = self._makeRenderer() + response = {'a':'1'} + 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') + + def test_with_headerlist(self): + renderer = self._makeRenderer() + response = {'a':'1'} + 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')]) + + def test_with_status(self): + renderer = self._makeRenderer() + response = {'a':'1'} + 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') + + def test_with_charset(self): + renderer = self._makeRenderer() + response = {'a':'1'} + request = DummyRequest() + attrs = {'response_charset':'UTF-16'} + request.__dict__.update(attrs) + result = self._callFUT(renderer, response, request=request) + self.assertEqual(result.charset, 'UTF-16') + + def test_with_cache_for(self): + renderer = self._makeRenderer() + response = {'a':'1'} + 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 Test_decorate_view(unittest.TestCase): + def _callFUT(self, wrapped, original): + from repoze.bfg.configuration 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 TestMultiView(unittest.TestCase): + def _getTargetClass(self): + from repoze.bfg.configuration 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) + + 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 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) -class DummyRegistryManager: - def push(self, registry): - from repoze.bfg.threadlocal import manager - manager.push(registry) - self.pushed = True + 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 pop(self): - from repoze.bfg.threadlocal import manager - manager.pop() - self.popped = True + 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.exceptions 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.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 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.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.configuration 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)) + + def test_function_noargs(self): + def foo(): + """ """ + self.assertFalse(self._callFUT(foo)) + + 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 DummyRequest: + pass class DummyRootFactory: def __init__(self, root): @@ -1359,3 +1788,8 @@ class IDummy(Interface): class IOther(Interface): pass + +class DummyResponse: + status = '200 OK' + headerlist = () + app_iter = () -- cgit v1.2.3