From 0c29cf2df41600d3906d521c72991c7686018b71 Mon Sep 17 00:00:00 2001 From: Michael Merickel Date: Mon, 15 Oct 2018 01:55:54 -0500 Subject: format source using black --- tests/test_config/test_views.py | 1759 ++++++++++++++++++++++++++++----------- 1 file changed, 1258 insertions(+), 501 deletions(-) (limited to 'tests/test_config/test_views.py') diff --git a/tests/test_config/test_views.py b/tests/test_config/test_views.py index 1af3f66bc..9b2a306f6 100644 --- a/tests/test_config/test_views.py +++ b/tests/test_config/test_views.py @@ -6,28 +6,34 @@ from . import IDummy from . import dummy_view -from pyramid.compat import ( - im_func, - text_, - ) +from pyramid.compat import im_func, text_ from pyramid.exceptions import ConfigurationError from pyramid.exceptions import ConfigurationExecutionError from pyramid.exceptions import ConfigurationConflictError + class TestViewsConfigurationMixin(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) config.set_default_csrf_options(require_csrf=False) return config - def _getViewCallable(self, config, ctx_iface=None, exc_iface=None, - request_iface=None, name=''): + def _getViewCallable( + self, + config, + ctx_iface=None, + exc_iface=None, + request_iface=None, + name='', + ): from zope.interface import Interface from pyramid.interfaces import IRequest from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + if exc_iface: classifier = IExceptionViewClassifier ctx_iface = exc_iface @@ -38,16 +44,22 @@ class TestViewsConfigurationMixin(unittest.TestCase): if request_iface is None: request_iface = IRequest return config.registry.adapters.lookup( - (classifier, request_iface, ctx_iface), IView, name=name, - default=None) + (classifier, request_iface, ctx_iface), + IView, + name=name, + default=None, + ) def _registerRenderer(self, config, name='.txt'): from pyramid.interfaces import IRendererFactory + class Renderer: def __init__(self, info): self.__class__.info = info + def __call__(self, *arg): return b'Hello!' + config.registry.registerUtility(Renderer, IRendererFactory, name=name) return Renderer @@ -58,15 +70,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): def _assertNotFound(self, wrapper, *arg): from pyramid.httpexceptions import HTTPNotFound + self.assertRaises(HTTPNotFound, wrapper, *arg) def _getRouteRequestIface(self, config, name): from pyramid.interfaces import IRouteRequest + iface = config.registry.getUtility(IRouteRequest, name) return iface def _assertRoute(self, config, name, path, num_predicates=0): from pyramid.interfaces import IRoutesMapper + mapper = config.registry.getUtility(IRoutesMapper) routes = mapper.get_routes() route = routes[0] @@ -83,18 +98,29 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_type_and_route_name(self): config = self._makeOne(autocommit=True) view = lambda *arg: 'OK' - self.assertRaises(ConfigurationError, config.add_view, view, '', None, - None, True, True) + self.assertRaises( + ConfigurationError, + config.add_view, + view, + '', + None, + None, + True, + True, + ) def test_add_view_with_request_type(self): from pyramid.renderers import null_renderer from zope.interface import directlyProvides from pyramid.interfaces import IRequest + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, - request_type='pyramid.interfaces.IRequest', - renderer=null_renderer) + config.add_view( + view=view, + request_type='pyramid.interfaces.IRequest', + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) request = DummyRequest() self._assertNotFound(wrapper, None, request) @@ -122,8 +148,9 @@ class TestViewsConfigurationMixin(unittest.TestCase): introspector = DummyIntrospector() config.introspector = introspector config.add_view(renderer='dummy.pt') - self.assertFalse(('renderer factories', '.pt') in - introspector.related[-1]) + self.assertFalse( + ('renderer factories', '.pt') in introspector.related[-1] + ) view = self._getViewCallable(config) self.assertRaises(ValueError, view, None, None) @@ -131,37 +158,45 @@ class TestViewsConfigurationMixin(unittest.TestCase): config = self._makeOne(autocommit=True) introspector = DummyIntrospector(True) config.introspector = introspector + def dummy_factory(helper): return lambda val, system_vals: 'Hello!' + config.add_renderer('.pt', dummy_factory) config.add_view(renderer='dummy.pt') self.assertTrue( - ('renderer factories', '.pt') in introspector.related[-1]) + ('renderer factories', '.pt') in introspector.related[-1] + ) view = self._getViewCallable(config) self.assertTrue(b'Hello!' in view(None, None).body) def test_add_view_wrapped_view_is_decorated(self): - def view(request): # request-only wrapper + def view(request): # request-only wrapper """ """ + config = self._makeOne(autocommit=True) config.add_view(view=view) wrapper = self._getViewCallable(config) self.assertEqual(wrapper.__module__, view.__module__) self.assertEqual(wrapper.__name__, view.__name__) self.assertEqual(wrapper.__doc__, view.__doc__) - self.assertEqual(wrapper.__discriminator__(None, None).resolve()[0], - 'view') + self.assertEqual( + wrapper.__discriminator__(None, None).resolve()[0], 'view' + ) def test_add_view_view_callable_dottedname(self): from pyramid.renderers import null_renderer + config = self._makeOne(autocommit=True) - config.add_view(view='tests.test_config.dummy_view', - renderer=null_renderer) + config.add_view( + view='tests.test_config.dummy_view', renderer=null_renderer + ) wrapper = self._getViewCallable(config) self.assertEqual(wrapper(None, None), 'OK') def test_add_view_with_function_callable(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) @@ -171,8 +206,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_function_callable_requestonly(self): from pyramid.renderers import null_renderer + def view(request): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) @@ -181,6 +218,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_name(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, name='abc', renderer=null_renderer) @@ -190,6 +228,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_name_unicode(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) name = text_(b'La Pe\xc3\xb1a', 'utf-8') @@ -200,16 +239,21 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_decorator(self): from pyramid.renderers import null_renderer + def view(request): """ ABC """ return 'OK' + def view_wrapper(fn): def inner(context, request): return fn(context, request) + return inner + config = self._makeOne(autocommit=True) - config.add_view(view=view, decorator=view_wrapper, - renderer=null_renderer) + config.add_view( + view=view, decorator=view_wrapper, renderer=null_renderer + ) wrapper = self._getViewCallable(config) self.assertFalse(wrapper is view) self.assertEqual(wrapper.__doc__, view.__doc__) @@ -218,20 +262,29 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_decorator_tuple(self): from pyramid.renderers import null_renderer + def view(request): """ ABC """ return 'OK' + def view_wrapper1(fn): def inner(context, request): return 'wrapped1' + fn(context, request) + return inner + def view_wrapper2(fn): def inner(context, request): return 'wrapped2' + fn(context, request) + return inner + config = self._makeOne(autocommit=True) - config.add_view(view=view, decorator=(view_wrapper2, view_wrapper1), - renderer=null_renderer) + config.add_view( + view=view, + decorator=(view_wrapper2, view_wrapper1), + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) self.assertFalse(wrapper is view) self.assertEqual(wrapper.__doc__, view.__doc__) @@ -241,12 +294,15 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_http_cache(self): import datetime from pyramid.response import Response + response = Response('OK') + def view(request): """ ABC """ return response + config = self._makeOne(autocommit=True) - config.add_view(view=view, http_cache=(86400, {'public':True})) + config.add_view(view=view, http_cache=(86400, {'public': True})) wrapper = self._getViewCallable(config) self.assertFalse(wrapper is view) self.assertEqual(wrapper.__doc__, view.__doc__) @@ -261,10 +317,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_instance(self): from pyramid.renderers import null_renderer + class AView: def __call__(self, context, request): """ """ return 'OK' + view = AView() config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) @@ -274,11 +332,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_instancemethod(self): from pyramid.renderers import null_renderer + class View: def index(self, context, request): return 'OK' + view = View() - config=self._makeOne(autocommit=True) + config = self._makeOne(autocommit=True) config.add_view(view=view.index, renderer=null_renderer) wrapper = self._getViewCallable(config) result = wrapper(None, None) @@ -286,11 +346,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_instancemethod_requestonly(self): from pyramid.renderers import null_renderer + class View: def index(self, request): return 'OK' + view = View() - config=self._makeOne(autocommit=True) + config = self._makeOne(autocommit=True) config.add_view(view=view.index, renderer=null_renderer) wrapper = self._getViewCallable(config) result = wrapper(None, None) @@ -298,10 +360,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_instance_requestonly(self): from pyramid.renderers import null_renderer + class AView: def __call__(self, request): """ """ return 'OK' + view = AView() config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) @@ -311,6 +375,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_oldstyle_class(self): from pyramid.renderers import null_renderer + class view: def __init__(self, context, request): self.context = context @@ -318,6 +383,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) @@ -328,12 +394,14 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_oldstyle_class_requestonly(self): from pyramid.renderers import null_renderer + class view: def __init__(self, request): self.request = request def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) @@ -346,9 +414,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_context_as_class(self): from pyramid.renderers import null_renderer from zope.interface import implementedBy + view = lambda *arg: 'OK' + class Foo: pass + config = self._makeOne(autocommit=True) config.add_view(context=Foo, view=view, renderer=null_renderer) foo = implementedBy(Foo) @@ -357,6 +428,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_context_as_iface(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(context=IDummy, view=view, renderer=null_renderer) @@ -365,19 +437,25 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_context_as_dottedname(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(context='tests.test_config.IDummy', - view=view, renderer=null_renderer) + config.add_view( + context='tests.test_config.IDummy', + view=view, + renderer=null_renderer, + ) wrapper = self._getViewCallable(config, IDummy) self.assertEqual(wrapper, view) def test_add_view_for__as_dottedname(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(for_='tests.test_config.IDummy', - view=view, renderer=null_renderer) + config.add_view( + for_='tests.test_config.IDummy', view=view, renderer=null_renderer + ) wrapper = self._getViewCallable(config, IDummy) self.assertEqual(wrapper, view) @@ -385,9 +463,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): # ``for_`` is older spelling for ``context`` from pyramid.renderers import null_renderer from zope.interface import implementedBy + view = lambda *arg: 'OK' + class Foo: pass + config = self._makeOne(autocommit=True) config.add_view(for_=Foo, view=view, renderer=null_renderer) foo = implementedBy(Foo) @@ -397,6 +478,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_for_as_iface(self): # ``for_`` is older spelling for ``context`` from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(for_=IDummy, view=view, renderer=null_renderer) @@ -406,12 +488,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_context_trumps_for(self): # ``for_`` is older spelling for ``context`` from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) + class Foo: pass - config.add_view(context=IDummy, for_=Foo, view=view, - renderer=null_renderer) + + config.add_view( + context=IDummy, for_=Foo, view=view, renderer=null_renderer + ) wrapper = self._getViewCallable(config, IDummy) self.assertEqual(wrapper, view) @@ -421,13 +507,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IRequest from pyramid.interfaces import ISecuredView from pyramid.interfaces import IViewClassifier + view = lambda *arg: 'OK' view.__call_permissive__ = view config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) wrapper = config.registry.adapters.lookup( (IViewClassifier, IRequest, Interface), - ISecuredView, name='', default=None) + ISecuredView, + name='', + default=None, + ) self.assertEqual(wrapper, view) def test_add_view_exception_register_secured_view(self): @@ -436,13 +526,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IRequest from pyramid.interfaces import IView from pyramid.interfaces import IExceptionViewClassifier + view = lambda *arg: 'OK' view.__call_permissive__ = view config = self._makeOne(autocommit=True) - config.add_view(view=view, context=RuntimeError, renderer=null_renderer) + config.add_view( + view=view, context=RuntimeError, renderer=null_renderer + ) wrapper = config.registry.adapters.lookup( (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='', default=None) + IView, + name='', + default=None, + ) self.assertEqual(wrapper, view) def test_add_view_same_phash_overrides_existing_single_view(self): @@ -453,15 +549,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + phash = md5() phash.update(b'xhr = True') view = lambda *arg: 'NOT OK' view.__phash__ = phash.hexdigest() config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) + def newview(context, request): return 'OK' + config.add_view(view=newview, xhr=True, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertFalse(IMultiView.providedBy(wrapper)) @@ -477,6 +577,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IExceptionViewClassifier from pyramid.interfaces import IMultiView + phash = md5() phash.update(b'xhr = True') view = lambda *arg: 'NOT OK' @@ -485,13 +586,22 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) + def newview(context, request): return 'OK' - config.add_view(view=newview, xhr=True, context=RuntimeError, - renderer=null_renderer) + + config.add_view( + view=newview, + xhr=True, + context=RuntimeError, + renderer=null_renderer, + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True @@ -504,12 +614,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'NOT OK' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) + def newview(context, request): return 'OK' + config.add_view(view=newview, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertFalse(IMultiView.providedBy(wrapper)) @@ -524,18 +638,25 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IExceptionViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'NOT OK' config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) + def newview(context, request): return 'OK' - config.add_view(view=newview, context=RuntimeError, - renderer=null_renderer) + + config.add_view( + view=newview, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True @@ -549,13 +670,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'NOT OK' view.__phash__ = DEFAULT_PHASH config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) + def newview(context, request): return 'OK' + config.add_view(view=newview, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertFalse(IMultiView.providedBy(wrapper)) @@ -571,19 +696,26 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IExceptionViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'NOT OK' view.__phash__ = DEFAULT_PHASH config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) + def newview(context, request): return 'OK' - config.add_view(view=newview, context=RuntimeError, - renderer=null_renderer) + + config.add_view( + view=newview, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True @@ -596,11 +728,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) @@ -614,21 +748,28 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IExceptionViewClassifier from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') - config.add_view(view=view, context=RuntimeError, - renderer=null_renderer) + IView, + name='', + ) + config.add_view( + view=view, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') @@ -639,12 +780,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import ISecuredView from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), - ISecuredView, name='') + view, (IViewClassifier, IRequest, Interface), ISecuredView, name='' + ) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) @@ -658,20 +800,28 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - ISecuredView, name='') + ISecuredView, + name='', + ) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - ISecuredView, name='') - config.add_view(view=view, context=RuntimeError, renderer=null_renderer) + ISecuredView, + name='', + ) + config.add_view( + view=view, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') @@ -682,13 +832,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + def view(context, request): return 'OK' + def view2(context, request): return 'OK2' + config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) config.add_view(view=view2, accept='text/html', renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) @@ -701,16 +855,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_mixed_case_replaces_existing_view(self): from pyramid.renderers import null_renderer - def view(context, request): return 'OK' - def view2(context, request): return 'OK2' - def view3(context, request): return 'OK3' + + def view(context, request): + return 'OK' + + def view2(context, request): + return 'OK2' + + def view3(context, request): + return 'OK3' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) config.add_view(view=view2, accept='text/html', renderer=null_renderer) config.add_view(view=view3, accept='text/HTML', renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) - self.assertEqual(len(wrapper.media_views.items()),1) + self.assertEqual(len(wrapper.media_views.items()), 1) self.assertFalse('text/HTML' in wrapper.media_views) self.assertEqual(wrapper(None, None), 'OK') request = DummyRequest() @@ -719,9 +880,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_views_with_accept_multiview_replaces_existing(self): from pyramid.renderers import null_renderer - def view(context, request): return 'OK' - def view2(context, request): return 'OK2' - def view3(context, request): return 'OK3' + + def view(context, request): + return 'OK' + + def view2(context, request): + return 'OK2' + + def view3(context, request): + return 'OK3' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) config.add_view(view=view2, accept='text/html', renderer=null_renderer) @@ -741,23 +909,35 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + def view(context, request): return 'OK' + def view2(context, request): return 'OK2' + config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') - config.add_view(view=view2, accept='text/html', context=RuntimeError, - renderer=null_renderer) + IView, + name='', + ) + config.add_view( + view=view2, + accept='text/html', + context=RuntimeError, + renderer=null_renderer, + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(len(wrapper.views), 1) self.assertEqual(len(wrapper.media_views), 1) @@ -773,15 +953,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + def view(context, request): return 'OK' + def view2(context, request): return 'OK2' + view.__accept__ = 'text/html' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) config.add_view(view=view2, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) @@ -800,25 +984,34 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + def view(context, request): return 'OK' + def view2(context, request): return 'OK2' + view.__accept__ = 'text/html' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') - config.add_view(view=view2, context=RuntimeError, - renderer=null_renderer) + IView, + name='', + ) + config.add_view( + view=view2, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(len(wrapper.views), 1) self.assertEqual(len(wrapper.media_views), 1) @@ -833,16 +1026,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IRequest from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + view = DummyMultiView() config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), - IMultiView, name='') + view, (IViewClassifier, IRequest, Interface), IMultiView, name='' + ) view2 = lambda *arg: 'OK2' config.add_view(view=view2, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) - self.assertEqual([(x[0], x[2]) for x in wrapper.views], [(view2, None)]) + self.assertEqual( + [(x[0], x[2]) for x in wrapper.views], [(view2, None)] + ) self.assertEqual(wrapper(None, None), 'OK1') def test_add_view_exc_multiview_replaces_multiviews(self): @@ -852,30 +1048,42 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + hot_view = DummyMultiView() exc_view = DummyMultiView() config = self._makeOne(autocommit=True) config.registry.registerAdapter( hot_view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IMultiView, name='') + IMultiView, + name='', + ) config.registry.registerAdapter( exc_view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IMultiView, name='') + IMultiView, + name='', + ) view2 = lambda *arg: 'OK2' - config.add_view(view=view2, context=RuntimeError, - renderer=null_renderer) + config.add_view( + view=view2, context=RuntimeError, renderer=null_renderer + ) hot_wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(RuntimeError)) + config, ctx_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(hot_wrapper)) - self.assertEqual([(x[0], x[2]) for x in hot_wrapper.views], [(view2, None)]) + self.assertEqual( + [(x[0], x[2]) for x in hot_wrapper.views], [(view2, None)] + ) self.assertEqual(hot_wrapper(None, None), 'OK1') exc_wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(exc_wrapper)) - self.assertEqual([(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)]) + self.assertEqual( + [(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)] + ) self.assertEqual(exc_wrapper(None, None), 'OK1') def test_add_view_exc_multiview_replaces_only_exc_multiview(self): @@ -885,30 +1093,43 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + hot_view = DummyMultiView() exc_view = DummyMultiView() config = self._makeOne(autocommit=True) config.registry.registerAdapter( hot_view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IMultiView, name='') + IMultiView, + name='', + ) config.registry.registerAdapter( exc_view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IMultiView, name='') + IMultiView, + name='', + ) view2 = lambda *arg: 'OK2' - config.add_view(view=view2, context=RuntimeError, exception_only=True, - renderer=null_renderer) + config.add_view( + view=view2, + context=RuntimeError, + exception_only=True, + renderer=null_renderer, + ) hot_wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(RuntimeError)) + config, ctx_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(hot_wrapper)) self.assertEqual(len(hot_wrapper.views), 0) self.assertEqual(hot_wrapper(None, None), 'OK1') exc_wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(exc_wrapper)) - self.assertEqual([(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)]) + self.assertEqual( + [(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)] + ) self.assertEqual(exc_wrapper(None, None), 'OK1') def test_add_view_multiview_context_superclass_then_subclass(self): @@ -918,22 +1139,28 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + class ISuper(Interface): pass + class ISub(ISuper): pass + view = lambda *arg: 'OK' view2 = lambda *arg: 'OK2' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, ISuper), IView, name='') + view, (IViewClassifier, IRequest, ISuper), IView, name='' + ) config.add_view(view=view2, for_=ISub, renderer=null_renderer) - wrapper = self._getViewCallable(config, ctx_iface=ISuper, - request_iface=IRequest) + wrapper = self._getViewCallable( + config, ctx_iface=ISuper, request_iface=IRequest + ) self.assertFalse(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') - wrapper = self._getViewCallable(config, ctx_iface=ISub, - request_iface=IRequest) + wrapper = self._getViewCallable( + config, ctx_iface=ISub, request_iface=IRequest + ) self.assertFalse(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK2') @@ -945,29 +1172,38 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + class Super(Exception): pass + class Sub(Super): pass + view = lambda *arg: 'OK' view2 = lambda *arg: 'OK2' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Super), IView, name='') + view, (IViewClassifier, IRequest, Super), IView, name='' + ) config.registry.registerAdapter( - view, (IExceptionViewClassifier, IRequest, Super), IView, name='') + view, (IExceptionViewClassifier, IRequest, Super), IView, name='' + ) config.add_view(view=view2, for_=Sub, renderer=null_renderer) wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(Super), request_iface=IRequest) + config, ctx_iface=implementedBy(Super), request_iface=IRequest + ) wrapper_exc_view = self._getViewCallable( - config, exc_iface=implementedBy(Super), request_iface=IRequest) + config, exc_iface=implementedBy(Super), request_iface=IRequest + ) self.assertEqual(wrapper_exc_view, wrapper) self.assertFalse(IMultiView.providedBy(wrapper_exc_view)) self.assertEqual(wrapper_exc_view(None, None), 'OK') wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(Sub), request_iface=IRequest) + config, ctx_iface=implementedBy(Sub), request_iface=IRequest + ) wrapper_exc_view = self._getViewCallable( - config, exc_iface=implementedBy(Sub), request_iface=IRequest) + config, exc_iface=implementedBy(Sub), request_iface=IRequest + ) self.assertEqual(wrapper_exc_view, wrapper) self.assertFalse(IMultiView.providedBy(wrapper_exc_view)) self.assertEqual(wrapper_exc_view(None, None), 'OK2') @@ -975,28 +1211,55 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_multiview_call_ordering(self): from pyramid.renderers import null_renderer as nr from zope.interface import directlyProvides - def view1(context, request): return 'view1' - def view2(context, request): return 'view2' - def view3(context, request): return 'view3' - def view4(context, request): return 'view4' - def view5(context, request): return 'view5' - def view6(context, request): return 'view6' - def view7(context, request): return 'view7' - def view8(context, request): return 'view8' + + def view1(context, request): + return 'view1' + + def view2(context, request): + return 'view2' + + def view3(context, request): + return 'view3' + + def view4(context, request): + return 'view4' + + def view5(context, request): + return 'view5' + + def view6(context, request): + return 'view6' + + def view7(context, request): + return 'view7' + + def view8(context, request): + return 'view8' + config = self._makeOne(autocommit=True) config.add_view(view=view1, renderer=nr) config.add_view(view=view2, request_method='POST', renderer=nr) - config.add_view(view=view3,request_param='param', renderer=nr) + config.add_view(view=view3, request_param='param', renderer=nr) config.add_view(view=view4, containment=IDummy, renderer=nr) - config.add_view(view=view5, request_method='POST', - request_param='param', renderer=nr) - config.add_view(view=view6, request_method='POST', containment=IDummy, - renderer=nr) - config.add_view(view=view7, request_param='param', containment=IDummy, - renderer=nr) - config.add_view(view=view8, request_method='POST',request_param='param', - containment=IDummy, renderer=nr) - + config.add_view( + view=view5, + request_method='POST', + request_param='param', + renderer=nr, + ) + config.add_view( + view=view6, request_method='POST', containment=IDummy, renderer=nr + ) + config.add_view( + view=view7, request_param='param', containment=IDummy, renderer=nr + ) + config.add_view( + view=view8, + request_method='POST', + request_param='param', + containment=IDummy, + renderer=nr, + ) wrapper = self._getViewCallable(config) @@ -1014,7 +1277,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): ctx = DummyContext() request = self._makeRequest(config) - request.params = {'param':'1'} + request.params = {'param': '1'} request.method = 'GET' self.assertEqual(wrapper(ctx, request), 'view3') @@ -1028,7 +1291,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): ctx = DummyContext() request = self._makeRequest(config) request.method = 'POST' - request.params = {'param':'1'} + request.params = {'param': '1'} self.assertEqual(wrapper(ctx, request), 'view5') ctx = DummyContext() @@ -1042,40 +1305,55 @@ class TestViewsConfigurationMixin(unittest.TestCase): directlyProvides(ctx, IDummy) request = self._makeRequest(config) request.method = 'GET' - request.params = {'param':'1'} + request.params = {'param': '1'} self.assertEqual(wrapper(ctx, request), 'view7') ctx = DummyContext() directlyProvides(ctx, IDummy) request = self._makeRequest(config) request.method = 'POST' - request.params = {'param':'1'} + request.params = {'param': '1'} self.assertEqual(wrapper(ctx, request), 'view8') def test_view_with_most_specific_predicate(self): from pyramid.renderers import null_renderer as nr from pyramid.router import Router - class OtherBase(object): pass - class Int1(object): pass - class Int2(object): pass + class OtherBase(object): + pass + + class Int1(object): + pass + + class Int2(object): + pass class Resource(OtherBase, Int1, Int2): - def __init__(self, request): pass + def __init__(self, request): + pass + + def unknown(context, request): + return 'unknown' - def unknown(context, request): return 'unknown' - def view(context, request): return 'hello' + def view(context, request): + return 'hello' config = self._makeOne(autocommit=True) config.add_route('root', '/', factory=Resource) config.add_view(unknown, route_name='root', renderer=nr) config.add_view( - view, renderer=nr, route_name='root', - context=Int1, request_method='GET' - ) + view, + renderer=nr, + route_name='root', + context=Int1, + request_method='GET', + ) config.add_view( - view=view, renderer=nr, route_name='root', - context=Int2, request_method='POST' + view=view, + renderer=nr, + route_name='root', + context=Int2, + request_method='POST', ) request = self._makeRequest(config) request.method = 'POST' @@ -1088,15 +1366,24 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.renderers import null_renderer as nr from pyramid.router import Router - class OtherBase(object): pass - class Int1(object): pass - class Int2(object): pass + class OtherBase(object): + pass + + class Int1(object): + pass + + class Int2(object): + pass class Resource(OtherBase, Int1, Int2): - def __init__(self, request): pass + def __init__(self, request): + pass - def unknown(context, request): return 'unknown' - def view(context, request): return 'hello' + def unknown(context, request): + return 'unknown' + + def view(context, request): + return 'hello' config = self._makeOne(autocommit=True) config.add_route('root', '/', factory=Resource) @@ -1110,12 +1397,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): ) config.add_view( - view, renderer=nr, route_name='root', - context=Int1, request_method='GET' + view, + renderer=nr, + route_name='root', + context=Int1, + request_method='GET', ) config.add_view( - view=view, renderer=nr, route_name='root', - context=Int2, request_method='POST' + view=view, + renderer=nr, + route_name='root', + context=Int2, + request_method='POST', ) request = self._makeRequest(config) request.method = 'POST' @@ -1127,16 +1420,21 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_multiview___discriminator__(self): from pyramid.renderers import null_renderer from zope.interface import Interface + class IFoo(Interface): pass + class IBar(Interface): pass + @implementer(IFoo) class Foo(object): pass + @implementer(IBar) class Bar(object): pass + foo = Foo() bar = Bar() @@ -1144,33 +1442,35 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') - config.add_view(view=view, renderer=null_renderer, - containment=IFoo) - config.add_view(view=view, renderer=null_renderer, - containment=IBar) + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) + config.add_view(view=view, renderer=null_renderer, containment=IFoo) + config.add_view(view=view, renderer=null_renderer, containment=IBar) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) request = self._makeRequest(config) self.assertNotEqual( wrapper.__discriminator__(foo, request), wrapper.__discriminator__(bar, request), - ) + ) def test_add_view_with_template_renderer(self): from tests import test_config from pyramid.interfaces import ISettings + class view(object): def __init__(self, context, request): self.request = request self.context = context def __call__(self): - return {'a':'1'} + return {'a': '1'} + config = self._makeOne(autocommit=True) renderer = self._registerRenderer(config) fixture = 'tests.test_config:files/minimal.txt' @@ -1195,13 +1495,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): self.context = context def __call__(self): - return {'a':'1'} + return {'a': '1'} + config = self._makeOne(autocommit=True) + class moo(object): def __init__(self, *arg, **kw): pass + def __call__(self, *arg, **kw): return b'moo' + config.add_renderer(None, moo) config.add_view(view=view) wrapper = self._getViewCallable(config) @@ -1212,6 +1516,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_template_renderer_no_callable(self): from tests import test_config from pyramid.interfaces import ISettings + config = self._makeOne(autocommit=True) renderer = self._registerRenderer(config) fixture = 'tests.test_config:files/minimal.txt' @@ -1232,8 +1537,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_type_as_iface(self): from pyramid.renderers import null_renderer from zope.interface import directlyProvides + def view(context, request): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(request_type=IDummy, view=view, renderer=null_renderer) wrapper = self._getViewCallable(config, None) @@ -1245,11 +1552,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_type_as_noniface(self): view = lambda *arg: 'OK' config = self._makeOne() - self.assertRaises(ConfigurationError, - config.add_view, view, '', None, None, object) + self.assertRaises( + ConfigurationError, config.add_view, view, '', None, None, object + ) def test_add_view_with_route_name(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_route('foo', '/a/b') @@ -1262,6 +1571,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_nonexistant_route_name(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne() config.add_view(view=view, route_name='foo', renderer=null_renderer) @@ -1270,28 +1580,39 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_route_name_exception(self): from pyramid.renderers import null_renderer from zope.interface import implementedBy + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_route('foo', '/a/b') - config.add_view(view=view, route_name='foo', context=RuntimeError, - renderer=null_renderer) + config.add_view( + view=view, + route_name='foo', + context=RuntimeError, + renderer=null_renderer, + ) request_iface = self._getRouteRequestIface(config, 'foo') wrapper_exc_view = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError), - request_iface=request_iface) + config, + exc_iface=implementedBy(RuntimeError), + request_iface=request_iface, + ) self.assertNotEqual(wrapper_exc_view, None) wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(RuntimeError), - request_iface=request_iface) + config, + ctx_iface=implementedBy(RuntimeError), + request_iface=request_iface, + ) self.assertEqual(wrapper_exc_view, wrapper) self.assertEqual(wrapper_exc_view(None, None), 'OK') def test_add_view_with_request_method_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_method='POST', - renderer=null_renderer) + config.add_view( + view=view, request_method='POST', renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) request.method = 'POST' @@ -1308,10 +1629,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_method_sequence_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_method=('POST', 'GET'), - renderer=null_renderer) + config.add_view( + view=view, request_method=('POST', 'GET'), renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) request.method = 'POST' @@ -1319,12 +1642,15 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_method_sequence_conflict(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne() - config.add_view(view=view, request_method=('POST', 'GET'), - renderer=null_renderer) - config.add_view(view=view, request_method=('GET', 'POST'), - renderer=null_renderer) + config.add_view( + view=view, request_method=('POST', 'GET'), renderer=null_renderer + ) + config.add_view( + view=view, request_method=('GET', 'POST'), renderer=null_renderer + ) self.assertRaises(ConfigurationConflictError, config.commit) def test_add_view_with_request_method_sequence_false(self): @@ -1338,9 +1664,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_method_get_implies_head(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_method='GET', renderer=null_renderer) + config.add_view( + view=view, request_method='GET', renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) request.method = 'HEAD' @@ -1348,12 +1677,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_param_noval_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, request_param='abc', renderer=null_renderer) wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.params = {'abc':''} + request.params = {'abc': ''} self.assertEqual(wrapper(None, request), 'OK') def test_add_view_with_request_param_noval_false(self): @@ -1367,13 +1697,15 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_param_val_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_param='abc=123', - renderer=null_renderer) + config.add_view( + view=view, request_param='abc=123', renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.params = {'abc':'123'} + request.params = {'abc': '123'} self.assertEqual(wrapper(None, request), 'OK') def test_add_view_with_request_param_val_false(self): @@ -1382,11 +1714,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.add_view(view=view, request_param='abc=123') wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.params = {'abc':''} + request.params = {'abc': ''} self._assertNotFound(wrapper, None, request) def test_add_view_with_xhr_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, xhr=True, renderer=null_renderer) @@ -1412,12 +1745,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_header_noval_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, header='Host', renderer=null_renderer) wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'Host':'whatever'} + request.headers = {'Host': 'whatever'} self.assertEqual(wrapper(None, request), 'OK') def test_add_view_with_header_noval_nomatch(self): @@ -1426,17 +1760,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.add_view(view=view, header='Host') wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'NotHost':'whatever'} + request.headers = {'NotHost': 'whatever'} self._assertNotFound(wrapper, None, request) def test_add_view_with_header_val_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, header=r'Host:\d', renderer=null_renderer) wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'Host':'1'} + request.headers = {'Host': '1'} self.assertEqual(wrapper(None, request), 'OK') def test_add_view_with_header_val_nomatch(self): @@ -1445,21 +1780,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.add_view(view=view, header=r'Host:\d') wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'Host':'abc'} + request.headers = {'Host': 'abc'} self._assertNotFound(wrapper, None, request) def test_add_view_with_header_val_missing(self): from pyramid.httpexceptions import HTTPNotFound + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, header=r'Host:\d') wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'NoHost':'1'} + request.headers = {'NoHost': '1'} self.assertRaises(HTTPNotFound, wrapper, None, request) def test_add_view_with_accept_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, accept='text/xml', renderer=null_renderer) @@ -1479,6 +1816,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_range_accept_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, accept='text/*', renderer=null_renderer) @@ -1499,6 +1837,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_containment_true(self): from pyramid.renderers import null_renderer from zope.interface import directlyProvides + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, containment=IDummy, renderer=null_renderer) @@ -1518,12 +1857,14 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_containment_dottedname(self): from pyramid.renderers import null_renderer from zope.interface import directlyProvides + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view( view=view, containment='tests.test_config.IDummy', - renderer=null_renderer) + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) context = DummyContext() directlyProvides(context, IDummy) @@ -1537,6 +1878,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_path_info_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, path_info='/foo', renderer=null_renderer) @@ -1557,6 +1899,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_check_csrf_predicates_match(self): import warnings from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) with warnings.catch_warnings(record=True) as w: @@ -1574,17 +1917,22 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_custom_predicates_match(self): import warnings from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) + def pred1(context, request): return True + def pred2(context, request): return True + predicates = (pred1, pred2) with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') - config.add_view(view=view, custom_predicates=predicates, - renderer=null_renderer) + config.add_view( + view=view, custom_predicates=predicates, renderer=null_renderer + ) self.assertEqual(len(w), 1) wrapper = self._getViewCallable(config) request = self._makeRequest(config) @@ -1592,12 +1940,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_custom_predicates_nomatch(self): import warnings + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) + def pred1(context, request): return True + def pred2(context, request): return False + predicates = (pred1, pred2) with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') @@ -1610,17 +1962,22 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_custom_predicate_bests_standard_predicate(self): import warnings from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' view2 = lambda *arg: 'NOT OK' config = self._makeOne(autocommit=True) + def pred1(context, request): return True + with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') - config.add_view(view=view, custom_predicates=(pred1,), - renderer=null_renderer) - config.add_view(view=view2, request_method='GET', - renderer=null_renderer) + config.add_view( + view=view, custom_predicates=(pred1,), renderer=null_renderer + ) + config.add_view( + view=view2, request_method='GET', renderer=null_renderer + ) self.assertEqual(len(w), 1) wrapper = self._getViewCallable(config) request = self._makeRequest(config) @@ -1629,13 +1986,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_custom_more_preds_first_bests_fewer_preds_last(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' view2 = lambda *arg: 'NOT OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_method='GET', xhr=True, - renderer=null_renderer) - config.add_view(view=view2, request_method='GET', - renderer=null_renderer) + config.add_view( + view=view, request_method='GET', xhr=True, renderer=null_renderer + ) + config.add_view( + view=view2, request_method='GET', renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) request.method = 'GET' @@ -1652,8 +2012,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_csrf_param(self): from pyramid.renderers import null_renderer + def view(request): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view, require_csrf='st', renderer=null_renderer) view = self._getViewCallable(config) @@ -1667,8 +2029,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_csrf_header(self): from pyramid.renderers import null_renderer + def view(request): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view, require_csrf=True, renderer=null_renderer) view = self._getViewCallable(config) @@ -1683,7 +2047,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_missing_csrf_header(self): from pyramid.exceptions import BadCSRFToken from pyramid.renderers import null_renderer - def view(request): return 'OK' + + def view(request): + return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view, require_csrf=True, renderer=null_renderer) view = self._getViewCallable(config) @@ -1697,21 +2064,27 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_permission(self): from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' outerself = self + class DummyPolicy(object): def effective_principals(self, r): outerself.assertEqual(r, request) return ['abc'] + def permits(self, context, principals, permission): outerself.assertEqual(context, None) outerself.assertEqual(principals, ['abc']) outerself.assertEqual(permission, 'view') return True + policy = DummyPolicy() - config = self._makeOne(authorization_policy=policy, - authentication_policy=policy, - autocommit=True) + config = self._makeOne( + authorization_policy=policy, + authentication_policy=policy, + autocommit=True, + ) config.add_view(view=view1, permission='view', renderer=null_renderer) view = self._getViewCallable(config) request = self._makeRequest(config) @@ -1719,22 +2092,28 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_default_permission_no_explicit_permission(self): from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' outerself = self + class DummyPolicy(object): def effective_principals(self, r): outerself.assertEqual(r, request) return ['abc'] + def permits(self, context, principals, permission): outerself.assertEqual(context, None) outerself.assertEqual(principals, ['abc']) outerself.assertEqual(permission, 'view') return True + policy = DummyPolicy() - config = self._makeOne(authorization_policy=policy, - authentication_policy=policy, - default_permission='view', - autocommit=True) + config = self._makeOne( + authorization_policy=policy, + authentication_policy=policy, + default_permission='view', + autocommit=True, + ) config.add_view(view=view1, renderer=null_renderer) view = self._getViewCallable(config) request = self._makeRequest(config) @@ -1742,12 +2121,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_no_default_permission_no_explicit_permission(self): from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' - class DummyPolicy(object): pass # wont be called + + class DummyPolicy(object): + pass # wont be called + policy = DummyPolicy() - config = self._makeOne(authorization_policy=policy, - authentication_policy=policy, - autocommit=True) + config = self._makeOne( + authorization_policy=policy, + authentication_policy=policy, + autocommit=True, + ) config.add_view(view=view1, renderer=null_renderer) view = self._getViewCallable(config) request = self._makeRequest(config) @@ -1755,13 +2140,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_mapper(self): from pyramid.renderers import null_renderer + class Mapper(object): def __init__(self, **kw): self.__class__.kw = kw + def __call__(self, view): return view + config = self._makeOne(autocommit=True) - def view(context, request): return 'OK' + + def view(context, request): + return 'OK' + config.add_view(view=view, mapper=Mapper, renderer=null_renderer) view = self._getViewCallable(config) self.assertEqual(view(None, None), 'OK') @@ -1771,18 +2162,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.renderers import null_renderer from pyramid.exceptions import PredicateMismatch from zope.interface import directlyProvides + class view(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + def __init__(self, request): pass + def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) - config.add_view( - view=view, - renderer=null_renderer) + config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) context = DummyContext() directlyProvides(context, IDummy) @@ -1796,10 +2187,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.renderers import null_renderer from pyramid.exceptions import PredicateMismatch from zope.interface import directlyProvides + config = self._makeOne(autocommit=True) config.add_view( view='tests.test_config.test_views.DummyViewDefaultsClass', - renderer=null_renderer) + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) context = DummyContext() directlyProvides(context, IDummy) @@ -1813,10 +2206,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.renderers import null_renderer from pyramid.exceptions import PredicateMismatch from zope.interface import directlyProvides + config = self._makeOne(autocommit=True) config.add_view( 'tests.test_config.test_views.DummyViewDefaultsClass', - renderer=null_renderer) + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) context = DummyContext() directlyProvides(context, IDummy) @@ -1828,40 +2223,30 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_view_config_and_view_defaults_doesnt_conflict(self): from pyramid.renderers import null_renderer + class view(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + class view2(object): - __view_defaults__ = { - 'containment':'tests.test_config.IFactory' - } + __view_defaults__ = {'containment': 'tests.test_config.IFactory'} + config = self._makeOne(autocommit=False) - config.add_view( - view=view, - renderer=null_renderer) - config.add_view( - view=view2, - renderer=null_renderer) - config.commit() # does not raise + config.add_view(view=view, renderer=null_renderer) + config.add_view(view=view2, renderer=null_renderer) + config.commit() # does not raise def test_add_view_with_view_config_and_view_defaults_conflicts(self): from pyramid.renderers import null_renderer + class view(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + class view2(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + config = self._makeOne(autocommit=False) - config.add_view( - view=view, - renderer=null_renderer) - config.add_view( - view=view2, - renderer=null_renderer) + config.add_view(view=view, renderer=null_renderer) + config.add_view(view=view2, renderer=null_renderer) self.assertRaises(ConfigurationConflictError, config.commit) def test_add_view_class_method_no_attr(self): @@ -1870,8 +2255,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.exceptions import ConfigurationError config = self._makeOne(autocommit=True) + class DummyViewClass(object): - def run(self): pass + def run(self): + pass def configure_view(): config.add_view(view=DummyViewClass.run, renderer=null_renderer) @@ -1881,41 +2268,62 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_exception_only_no_regular_view(self): from zope.interface import implementedBy from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view1, context=Exception, exception_only=True, - renderer=null_renderer) - view = self._getViewCallable(config, ctx_iface=implementedBy(Exception)) + config.add_view( + view=view1, + context=Exception, + exception_only=True, + renderer=null_renderer, + ) + view = self._getViewCallable( + config, ctx_iface=implementedBy(Exception) + ) self.assertTrue(view is None) def test_add_view_exception_only(self): from zope.interface import implementedBy from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view1, context=Exception, exception_only=True, - renderer=null_renderer) + config.add_view( + view=view1, + context=Exception, + exception_only=True, + renderer=null_renderer, + ) view = self._getViewCallable( - config, exc_iface=implementedBy(Exception)) + config, exc_iface=implementedBy(Exception) + ) self.assertEqual(view1, view) def test_add_view_exception_only_misconfiguration(self): view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) + class NotAnException(object): pass + self.assertRaises( ConfigurationError, - config.add_view, view, context=NotAnException, exception_only=True) + config.add_view, + view, + context=NotAnException, + exception_only=True, + ) def test_add_exception_view(self): from zope.interface import implementedBy from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_exception_view(view=view1, renderer=null_renderer) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(Exception)) + config, exc_iface=implementedBy(Exception) + ) context = Exception() request = self._makeRequest(config) self.assertEqual(wrapper(context, request), 'OK') @@ -1923,71 +2331,86 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_exception_view_with_subclass(self): from zope.interface import implementedBy from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_exception_view(view=view1, context=ValueError, - renderer=null_renderer) + config.add_exception_view( + view=view1, context=ValueError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(ValueError)) + config, exc_iface=implementedBy(ValueError) + ) context = ValueError() request = self._makeRequest(config) self.assertEqual(wrapper(context, request), 'OK') def test_add_exception_view_disallows_name(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - name='foo') + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + name='foo', + ) def test_add_exception_view_disallows_permission(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - permission='foo') + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + permission='foo', + ) def test_add_exception_view_disallows_require_csrf(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - require_csrf=True) + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + require_csrf=True, + ) def test_add_exception_view_disallows_for_(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - for_='foo') + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + for_='foo', + ) def test_add_exception_view_disallows_exception_only(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - exception_only=True) + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + exception_only=True, + ) def test_add_exception_view_with_view_defaults(self): from pyramid.renderers import null_renderer from pyramid.exceptions import PredicateMismatch from zope.interface import directlyProvides from zope.interface import implementedBy + class view(object): - __view_defaults__ = { - 'containment': 'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + def __init__(self, request): pass + def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) config.add_exception_view( - view=view, - context=Exception, - renderer=null_renderer) + view=view, context=Exception, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(Exception)) + config, exc_iface=implementedBy(Exception) + ) context = DummyContext() directlyProvides(context, IDummy) request = self._makeRequest(config) @@ -1998,8 +2421,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_derive_view_function(self): from pyramid.renderers import null_renderer + def view(request): return 'OK' + config = self._makeOne() result = config.derive_view(view, renderer=null_renderer) self.assertFalse(result is view) @@ -2007,37 +2432,48 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_derive_view_dottedname(self): from pyramid.renderers import null_renderer + config = self._makeOne() result = config.derive_view( - 'tests.test_config.dummy_view', - renderer=null_renderer) + 'tests.test_config.dummy_view', renderer=null_renderer + ) self.assertFalse(result is dummy_view) self.assertEqual(result(None, None), 'OK') def test_derive_view_with_default_renderer_no_explicit_renderer(self): config = self._makeOne() + class moo(object): def __init__(self, view): pass + def __call__(self, *arg, **kw): return 'moo' + config.add_renderer(None, moo) config.commit() + def view(request): return 'OK' + result = config.derive_view(view) self.assertFalse(result is view) self.assertEqual(result(None, None).body, b'moo') def test_derive_view_with_default_renderer_with_explicit_renderer(self): - class moo(object): pass + class moo(object): + pass + class foo(object): def __init__(self, view): pass + def __call__(self, *arg, **kw): return b'foo' + def view(request): return 'OK' + config = self._makeOne() config.add_renderer(None, moo) config.add_renderer('foo', foo) @@ -2052,64 +2488,71 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import Interface from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier + config = self._makeOne(autocommit=True) config.add_static_view('static', 'files', renderer=null_renderer) request_type = self._getRouteRequestIface(config, '__static/') self._assertRoute(config, '__static/', 'static/*subpath') wrapped = config.registry.adapters.lookup( - (IViewClassifier, request_type, Interface), IView, name='') + (IViewClassifier, request_type, Interface), IView, name='' + ) from pyramid.request import Request + request = Request.blank('/static/minimal.txt') - request.subpath = ('minimal.txt', ) + request.subpath = ('minimal.txt',) result = wrapped(None, request) self.assertEqual(result.status, '200 OK') self.assertTrue(result.body.startswith(b'