From 0c29cf2df41600d3906d521c72991c7686018b71 Mon Sep 17 00:00:00 2001
From: Michael Merickel <michael@merickel.org>
Date: Mon, 15 Oct 2018 16:24:07 +0200
Subject: [PATCH] format source using black
---
tests/test_router.py | 566 ++++++++++++++++++++++++++++++++++++++++++++------------
1 files changed, 441 insertions(+), 125 deletions(-)
diff --git a/tests/test_router.py b/tests/test_router.py
index 6097018..f06cfe5 100644
--- a/tests/test_router.py
+++ b/tests/test_router.py
@@ -2,6 +2,7 @@
from pyramid import testing
+
class TestRouter(unittest.TestCase):
def setUp(self):
self.config = testing.setUp()
@@ -13,6 +14,7 @@
def _registerRouteRequest(self, name):
from pyramid.interfaces import IRouteRequest
from pyramid.request import route_request_iface
+
iface = route_request_iface(name)
self.registry.registerUtility(iface, IRouteRequest, name=name)
return iface
@@ -20,6 +22,7 @@
def _connectRoute(self, name, path, factory=None):
from pyramid.interfaces import IRoutesMapper
from pyramid.urldispatch import RoutesMapper
+
mapper = self.registry.queryUtility(IRoutesMapper)
if mapper is None:
mapper = RoutesMapper()
@@ -28,21 +31,31 @@
def _registerLogger(self):
from pyramid.interfaces import IDebugLogger
+
logger = DummyLogger()
self.registry.registerUtility(logger, IDebugLogger)
return logger
def _registerSettings(self, **kw):
- settings = {'debug_authorization':False,
- 'debug_notfound':False,
- 'debug_routematch':False}
+ settings = {
+ 'debug_authorization': False,
+ 'debug_notfound': False,
+ 'debug_routematch': False,
+ }
settings.update(kw)
self.registry.settings = settings
- def _registerTraverserFactory(self, context, view_name='', subpath=None,
- traversed=None, virtual_root=None,
- virtual_root_path=None, raise_error=None,
- **kw):
+ def _registerTraverserFactory(
+ self,
+ context,
+ view_name='',
+ subpath=None,
+ traversed=None,
+ virtual_root=None,
+ virtual_root_path=None,
+ raise_error=None,
+ **kw
+ ):
from pyramid.interfaces import ITraverser
if virtual_root is None:
@@ -61,39 +74,48 @@
def __call__(self, request):
if raise_error:
raise raise_error
- values = {'root':self.root,
- 'context':context,
- 'view_name':view_name,
- 'subpath':subpath,
- 'traversed':traversed,
- 'virtual_root':virtual_root,
- 'virtual_root_path':virtual_root_path}
+ values = {
+ 'root': self.root,
+ 'context': context,
+ 'view_name': view_name,
+ 'subpath': subpath,
+ 'traversed': traversed,
+ 'virtual_root': virtual_root,
+ 'virtual_root_path': virtual_root_path,
+ }
kw.update(values)
return kw
- self.registry.registerAdapter(DummyTraverserFactory, (None,),
- ITraverser, name='')
+ self.registry.registerAdapter(
+ DummyTraverserFactory, (None,), ITraverser, name=''
+ )
def _registerView(self, app, name, classifier, req_iface, ctx_iface):
from pyramid.interfaces import IView
+
self.registry.registerAdapter(
- app, (classifier, req_iface, ctx_iface), IView, name)
+ app, (classifier, req_iface, ctx_iface), IView, name
+ )
def _registerEventListener(self, iface):
L = []
+
def listener(event):
L.append(event)
+
self.registry.registerHandler(listener, (iface,))
return L
def _registerRootFactory(self, val):
rootfactory = DummyRootFactory(val)
from pyramid.interfaces import IRootFactory
+
self.registry.registerUtility(rootfactory, IRootFactory)
return rootfactory
def _getTargetClass(self):
from pyramid.router import Router
+
return Router
def _makeOne(self):
@@ -102,12 +124,12 @@
def _makeEnviron(self, **extras):
environ = {
- 'wsgi.url_scheme':'http',
- 'SERVER_NAME':'localhost',
- 'SERVER_PORT':'8080',
- 'REQUEST_METHOD':'GET',
- 'PATH_INFO':'/',
- }
+ 'wsgi.url_scheme': 'http',
+ 'SERVER_NAME': 'localhost',
+ 'SERVER_PORT': '8080',
+ 'REQUEST_METHOD': 'GET',
+ 'PATH_INFO': '/',
+ }
environ.update(extras)
return environ
@@ -128,8 +150,10 @@
def test_request_factory(self):
from pyramid.interfaces import IRequestFactory
+
class DummyRequestFactory(object):
pass
+
self.registry.registerUtility(DummyRequestFactory, IRequestFactory)
router = self._makeOne()
self.assertEqual(router.request_factory, DummyRequestFactory)
@@ -140,41 +164,53 @@
from pyramid.response import Response
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IResponse
+
tweens = Tweens()
self.registry.registerUtility(tweens, ITweens)
L = []
+
def tween_factory1(handler, registry):
L.append((handler, registry))
+
def wrapper(request):
request.environ['handled'].append('one')
return handler(request)
+
wrapper.name = 'one'
wrapper.child = handler
return wrapper
+
def tween_factory2(handler, registry):
L.append((handler, registry))
+
def wrapper(request):
request.environ['handled'] = ['two']
return handler(request)
+
wrapper.name = 'two'
wrapper.child = handler
return wrapper
+
tweens.add_implicit('one', tween_factory1)
tweens.add_implicit('two', tween_factory2)
router = self._makeOne()
self.assertEqual(router.handle_request.name, 'two')
self.assertEqual(router.handle_request.child.name, 'one')
- self.assertEqual(router.handle_request.child.child.__name__,
- 'handle_request')
+ self.assertEqual(
+ router.handle_request.child.child.__name__, 'handle_request'
+ )
context = DummyContext()
self._registerTraverserFactory(context)
environ = self._makeEnviron()
view = DummyView('abc')
- self._registerView(self.config.derive_view(view), '',
- IViewClassifier, None, None)
+ self._registerView(
+ self.config.derive_view(view), '', IViewClassifier, None, None
+ )
start_response = DummyStartResponse()
+
def make_response(s):
return Response(s)
+
router.registry.registerAdapter(make_response, (str,), IResponse)
app_iter = router(environ, start_response)
self.assertEqual(app_iter, [b'abc'])
@@ -183,6 +219,7 @@
def test_call_traverser_default(self):
from pyramid.httpexceptions import HTTPNotFound
+
environ = self._makeEnviron()
logger = self._registerLogger()
router = self._makeOne()
@@ -194,6 +231,7 @@
def test_traverser_raises_notfound_class(self):
from pyramid.httpexceptions import HTTPNotFound
+
environ = self._makeEnviron()
context = DummyContext()
self._registerTraverserFactory(context, raise_error=HTTPNotFound)
@@ -203,9 +241,12 @@
def test_traverser_raises_notfound_instance(self):
from pyramid.httpexceptions import HTTPNotFound
+
environ = self._makeEnviron()
context = DummyContext()
- self._registerTraverserFactory(context, raise_error=HTTPNotFound('foo'))
+ self._registerTraverserFactory(
+ context, raise_error=HTTPNotFound('foo')
+ )
router = self._makeOne()
start_response = DummyStartResponse()
why = exc_raised(HTTPNotFound, router, environ, start_response)
@@ -213,6 +254,7 @@
def test_traverser_raises_forbidden_class(self):
from pyramid.httpexceptions import HTTPForbidden
+
environ = self._makeEnviron()
context = DummyContext()
self._registerTraverserFactory(context, raise_error=HTTPForbidden)
@@ -222,10 +264,12 @@
def test_traverser_raises_forbidden_instance(self):
from pyramid.httpexceptions import HTTPForbidden
+
environ = self._makeEnviron()
context = DummyContext()
- self._registerTraverserFactory(context,
- raise_error=HTTPForbidden('foo'))
+ self._registerTraverserFactory(
+ context, raise_error=HTTPForbidden('foo')
+ )
router = self._makeOne()
start_response = DummyStartResponse()
why = exc_raised(HTTPForbidden, router, environ, start_response)
@@ -233,6 +277,7 @@
def test_call_no_view_registered_no_isettings(self):
from pyramid.httpexceptions import HTTPNotFound
+
environ = self._makeEnviron()
context = DummyContext()
self._registerTraverserFactory(context)
@@ -246,6 +291,7 @@
def test_call_no_view_registered_debug_notfound_false(self):
from pyramid.httpexceptions import HTTPNotFound
+
environ = self._makeEnviron()
context = DummyContext()
self._registerTraverserFactory(context)
@@ -260,6 +306,7 @@
def test_call_no_view_registered_debug_notfound_true(self):
from pyramid.httpexceptions import HTTPNotFound
+
environ = self._makeEnviron()
context = DummyContext()
self._registerTraverserFactory(context)
@@ -269,7 +316,8 @@
start_response = DummyStartResponse()
why = exc_raised(HTTPNotFound, router, environ, start_response)
self.assertTrue(
- "debug_notfound of url http://localhost:8080/; " in why.args[0])
+ "debug_notfound of url http://localhost:8080/; " in why.args[0]
+ )
self.assertTrue("view_name: '', subpath: []" in why.args[0])
self.assertTrue('http://localhost:8080' in why.args[0], why)
@@ -283,12 +331,14 @@
def test_call_view_returns_non_iresponse(self):
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
self._registerTraverserFactory(context)
environ = self._makeEnviron()
view = DummyView('abc')
- self._registerView(self.config.derive_view(view), '', IViewClassifier,
- None, None)
+ self._registerView(
+ self.config.derive_view(view), '', IViewClassifier, None, None
+ )
router = self._makeOne()
start_response = DummyStartResponse()
self.assertRaises(ValueError, router, environ, start_response)
@@ -297,16 +347,20 @@
from pyramid.response import Response
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IResponse
+
context = DummyContext()
self._registerTraverserFactory(context)
environ = self._makeEnviron()
view = DummyView('abc')
- self._registerView(self.config.derive_view(view), '',
- IViewClassifier, None, None)
+ self._registerView(
+ self.config.derive_view(view), '', IViewClassifier, None, None
+ )
router = self._makeOne()
start_response = DummyStartResponse()
+
def make_response(s):
return Response(s)
+
router.registry.registerAdapter(make_response, (str,), IResponse)
app_iter = router(environ, start_response)
self.assertEqual(app_iter, [b'abc'])
@@ -318,12 +372,15 @@
from pyramid.interfaces import IRequest
from pyramid.request import Request
from pyramid.util import InstancePropertyHelper
+
context = DummyContext()
self._registerTraverserFactory(context)
+
class Extensions(object):
def __init__(self):
self.methods = {}
self.descriptors = {}
+
extensions = Extensions()
ext_method = lambda r: 'bar'
name, fn = InstancePropertyHelper.make_property(ext_method, name='foo')
@@ -331,15 +388,18 @@
request = Request.blank('/')
request.request_iface = IRequest
request.registry = self.registry
+
def request_factory(environ):
return request
+
self.registry.registerUtility(extensions, IRequestExtensions)
environ = self._makeEnviron()
response = DummyResponse()
response.app_iter = ['Hello world']
view = DummyView(response)
- self._registerView(self.config.derive_view(view), '',
- IViewClassifier, None, None)
+ self._registerView(
+ self.config.derive_view(view), '', IViewClassifier, None, None
+ )
router = self._makeOne()
router.request_factory = request_factory
start_response = DummyStartResponse()
@@ -348,14 +408,16 @@
def test_call_view_registered_nonspecific_default_path(self):
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
self._registerTraverserFactory(context)
response = DummyResponse()
response.app_iter = ['Hello world']
view = DummyView(response)
environ = self._makeEnviron()
- self._registerView(self.config.derive_view(view), '',
- IViewClassifier, None, None)
+ self._registerView(
+ self.config.derive_view(view), '', IViewClassifier, None, None
+ )
self._registerRootFactory(context)
router = self._makeOne()
start_response = DummyStartResponse()
@@ -369,12 +431,15 @@
self.assertEqual(request.context, context)
self.assertEqual(request.root, context)
- def test_call_view_registered_nonspecific_nondefault_path_and_subpath(self):
+ def test_call_view_registered_nonspecific_nondefault_path_and_subpath(
+ self
+ ):
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
- self._registerTraverserFactory(context, view_name='foo',
- subpath=['bar'],
- traversed=['context'])
+ self._registerTraverserFactory(
+ context, view_name='foo', subpath=['bar'], traversed=['context']
+ )
self._registerRootFactory(context)
response = DummyResponse()
response.app_iter = ['Hello world']
@@ -396,10 +461,13 @@
def test_call_view_registered_specific_success(self):
from zope.interface import Interface
from zope.interface import directlyProvides
+
class IContext(Interface):
pass
+
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
directlyProvides(context, IContext)
self._registerTraverserFactory(context)
@@ -426,11 +494,15 @@
from zope.interface import directlyProvides
from pyramid.httpexceptions import HTTPNotFound
from pyramid.interfaces import IViewClassifier
+
class IContext(Interface):
pass
+
class INotContext(Interface):
pass
+
from pyramid.interfaces import IRequest
+
context = DummyContext()
directlyProvides(context, INotContext)
self._registerTraverserFactory(context, subpath=[''])
@@ -446,16 +518,20 @@
from zope.interface import Interface
from zope.interface import directlyProvides
from pyramid.httpexceptions import HTTPForbidden
+
class IContext(Interface):
pass
+
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
directlyProvides(context, IContext)
self._registerTraverserFactory(context, subpath=[''])
response = DummyResponse()
- view = DummyView(response,
- raise_exception=HTTPForbidden("unauthorized"))
+ view = DummyView(
+ response, raise_exception=HTTPForbidden("unauthorized")
+ )
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, IContext)
router = self._makeOne()
@@ -466,11 +542,14 @@
def test_call_view_raises_notfound(self):
from zope.interface import Interface
from zope.interface import directlyProvides
+
class IContext(Interface):
pass
+
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.httpexceptions import HTTPNotFound
+
context = DummyContext()
directlyProvides(context, IContext)
self._registerTraverserFactory(context, subpath=[''])
@@ -487,24 +566,31 @@
from zope.interface import Interface
from zope.interface import directlyProvides
from pyramid.interfaces import IExceptionViewClassifier
+
class IContext(Interface):
pass
+
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
directlyProvides(context, IContext)
self._registerTraverserFactory(context, subpath=[''])
+
def view(context, request):
request.response.a = 1
raise KeyError
+
def exc_view(context, request):
self.assertFalse(hasattr(request.response, 'a'))
request.response.body = b'OK'
return request.response
+
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, IContext)
- self._registerView(exc_view, '', IExceptionViewClassifier,
- IRequest, KeyError)
+ self._registerView(
+ exc_view, '', IExceptionViewClassifier, IRequest, KeyError
+ )
router = self._makeOne()
start_response = DummyStartResponse()
itera = router(environ, start_response)
@@ -513,19 +599,25 @@
def test_call_request_has_response_callbacks(self):
from zope.interface import Interface
from zope.interface import directlyProvides
+
class IContext(Interface):
pass
+
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
directlyProvides(context, IContext)
self._registerTraverserFactory(context, subpath=[''])
response = DummyResponse('200 OK')
+
def view(context, request):
def callback(request, response):
response.called_back = True
+
request.add_response_callback(callback)
return response
+
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, IContext)
router = self._makeOne()
@@ -536,19 +628,25 @@
def test_call_request_has_finished_callbacks_when_view_succeeds(self):
from zope.interface import Interface
from zope.interface import directlyProvides
+
class IContext(Interface):
pass
+
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
directlyProvides(context, IContext)
self._registerTraverserFactory(context, subpath=[''])
response = DummyResponse('200 OK')
+
def view(context, request):
def callback(request):
request.environ['called_back'] = True
+
request.add_finished_callback(callback)
return response
+
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, IContext)
router = self._makeOne()
@@ -559,18 +657,24 @@
def test_call_request_has_finished_callbacks_when_view_raises(self):
from zope.interface import Interface
from zope.interface import directlyProvides
+
class IContext(Interface):
pass
+
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
directlyProvides(context, IContext)
self._registerTraverserFactory(context, subpath=[''])
+
def view(context, request):
def callback(request):
request.environ['called_back'] = True
+
request.add_finished_callback(callback)
raise NotImplementedError
+
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, IContext)
router = self._makeOne()
@@ -582,8 +686,10 @@
# making sure finally doesnt barf when a request cannot be created
environ = self._makeEnviron()
router = self._makeOne()
+
def dummy_request_factory(environ):
raise NotImplementedError
+
router.request_factory = dummy_request_factory
start_response = DummyStartResponse()
exc_raised(NotImplementedError, router, environ, start_response)
@@ -594,6 +700,7 @@
from pyramid.interfaces import IBeforeTraversal
from pyramid.interfaces import IContextFound
from pyramid.interfaces import IViewClassifier
+
context = DummyContext()
self._registerTraverserFactory(context)
response = DummyResponse()
@@ -624,18 +731,22 @@
from pyramid.interfaces import INewRequest
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
context = DummyContext()
self._registerTraverserFactory(context)
environ = self._makeEnviron()
+
def listener(event):
raise KeyError
+
self.registry.registerHandler(listener, (INewRequest,))
exception_response = DummyResponse()
exception_response.app_iter = ["Hello, world"]
exception_view = DummyView(exception_response)
environ = self._makeEnviron()
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, KeyError)
+ self._registerView(
+ exception_view, '', IExceptionViewClassifier, IRequest, KeyError
+ )
router = self._makeOne()
start_response = DummyStartResponse()
result = router(environ, start_response)
@@ -643,12 +754,15 @@
def test_call_route_matches_and_has_factory(self):
from pyramid.interfaces import IViewClassifier
+
logger = self._registerLogger()
self._registerSettings(debug_routematch=True)
self._registerRouteRequest('foo')
root = object()
+
def factory(request):
return root
+
route = self._connectRoute('foo', 'archives/:action/:article', factory)
route.predicates = [DummyPredicate()]
context = DummyContext()
@@ -670,23 +784,23 @@
self.assertEqual(request.subpath, [])
self.assertEqual(request.context, context)
self.assertEqual(request.root, root)
- matchdict = {'action':'action1', 'article':'article1'}
+ matchdict = {'action': 'action1', 'article': 'article1'}
self.assertEqual(request.matchdict, matchdict)
self.assertEqual(request.matched_route.name, 'foo')
self.assertEqual(len(logger.messages), 1)
self.assertTrue(
logger.messages[0].startswith(
- "route matched for url http://localhost:8080"
- "/archives/action1/article1; "
- "route_name: 'foo', "
- "path_info: ")
+ "route matched for url http://localhost:8080"
+ "/archives/action1/article1; "
+ "route_name: 'foo', "
+ "path_info: "
)
- self.assertTrue(
- "predicates: 'predicate'" in logger.messages[0]
- )
+ )
+ self.assertTrue("predicates: 'predicate'" in logger.messages[0])
def test_call_route_match_miss_debug_routematch(self):
from pyramid.httpexceptions import HTTPNotFound
+
logger = self._registerLogger()
self._registerSettings(debug_routematch=True)
self._registerRouteRequest('foo')
@@ -702,22 +816,29 @@
self.assertEqual(len(logger.messages), 1)
self.assertEqual(
logger.messages[0],
- 'no route matched for url http://localhost:8080/wontmatch')
+ 'no route matched for url http://localhost:8080/wontmatch',
+ )
def test_call_route_matches_doesnt_overwrite_subscriber_iface(self):
from pyramid.interfaces import INewRequest
from pyramid.interfaces import IViewClassifier
from zope.interface import alsoProvides
from zope.interface import Interface
+
self._registerRouteRequest('foo')
+
class IFoo(Interface):
pass
+
def listener(event):
alsoProvides(event.request, IFoo)
+
self.registry.registerHandler(listener, (INewRequest,))
root = object()
+
def factory(request):
return root
+
self._connectRoute('foo', 'archives/:action/:article', factory)
context = DummyContext()
self._registerTraverserFactory(context)
@@ -738,7 +859,7 @@
self.assertEqual(request.subpath, [])
self.assertEqual(request.context, context)
self.assertEqual(request.root, root)
- matchdict = {'action':'action1', 'article':'article1'}
+ matchdict = {'action': 'action1', 'article': 'article1'}
self.assertEqual(request.matchdict, matchdict)
self.assertEqual(request.matched_route.name, 'foo')
self.assertTrue(IFoo.providedBy(request))
@@ -748,11 +869,15 @@
from pyramid.httpexceptions import HTTPNotFound
from zope.interface import Interface
from zope.interface import directlyProvides
+
def rootfactory(request):
raise HTTPNotFound('from root factory')
+
self.registry.registerUtility(rootfactory, IRootFactory)
+
class IContext(Interface):
pass
+
context = DummyContext()
directlyProvides(context, IContext)
environ = self._makeEnviron()
@@ -766,11 +891,15 @@
from pyramid.httpexceptions import HTTPForbidden
from zope.interface import Interface
from zope.interface import directlyProvides
+
def rootfactory(request):
raise HTTPForbidden('from root factory')
+
self.registry.registerUtility(rootfactory, IRootFactory)
+
class IContext(Interface):
pass
+
context = DummyContext()
directlyProvides(context, IContext)
environ = self._makeEnviron()
@@ -783,11 +912,15 @@
from pyramid.interfaces import IRootFactory
from zope.interface import Interface
from zope.interface import directlyProvides
+
def rootfactory(request):
raise RuntimeError()
+
self.registry.registerUtility(rootfactory, IRootFactory)
+
class IContext(Interface):
pass
+
context = DummyContext()
directlyProvides(context, IContext)
environ = self._makeEnviron()
@@ -806,16 +939,21 @@
def test_call_view_exception_propagating(self):
from zope.interface import Interface
from zope.interface import directlyProvides
+
class IContext(Interface):
pass
+
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IRequestFactory
from pyramid.interfaces import IExceptionViewClassifier
+
def rfactory(environ):
return request
+
self.registry.registerUtility(rfactory, IRequestFactory)
from pyramid.request import Request
+
request = Request.blank('/')
context = DummyContext()
directlyProvides(context, IContext)
@@ -825,12 +963,19 @@
error = RuntimeError()
view = DummyView(response, raise_exception=error)
environ = self._makeEnviron()
+
def exception_view(context, request):
self.assertEqual(request.exc_info[0], RuntimeError)
return response
+
self._registerView(view, '', IViewClassifier, IRequest, IContext)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ RuntimeError,
+ )
router = self._makeOne()
start_response = DummyStartResponse()
result = router(environ, start_response)
@@ -839,23 +984,31 @@
# the excview tween has run (see
# https://github.com/Pylons/pyramid/issues/1223)
self.assertEqual(request.exception, error)
- self.assertEqual(request.exc_info[:2], (RuntimeError, error,))
-
+ self.assertEqual(request.exc_info[:2], (RuntimeError, error))
+
def test_call_view_raises_exception_view(self):
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
response = DummyResponse()
exception_response = DummyResponse()
exception_response.app_iter = ["Hello, world"]
view = DummyView(response, raise_exception=RuntimeError)
+
def exception_view(context, request):
self.assertEqual(request.exception.__class__, RuntimeError)
return exception_response
+
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, None)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ RuntimeError,
+ )
router = self._makeOne()
start_response = DummyStartResponse()
result = router(environ, start_response)
@@ -865,10 +1018,13 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
class SuperException(Exception):
pass
+
class SubException(SuperException):
pass
+
response = DummyResponse()
exception_response = DummyResponse()
exception_response.app_iter = ["Hello, world"]
@@ -876,8 +1032,13 @@
exception_view = DummyView(exception_response)
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, None)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, SubException)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ SubException,
+ )
router = self._makeOne()
start_response = DummyStartResponse()
self.assertRaises(SuperException, router, environ, start_response)
@@ -886,10 +1047,13 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
class SuperException(Exception):
pass
+
class SubException(SuperException):
pass
+
response = DummyResponse()
exception_response = DummyResponse()
exception_response.app_iter = ["Hello, world"]
@@ -897,8 +1061,13 @@
exception_view = DummyView(exception_response)
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, None)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, SuperException)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ SuperException,
+ )
router = self._makeOne()
start_response = DummyStartResponse()
result = router(environ, start_response)
@@ -908,10 +1077,13 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
class MyException(Exception):
pass
+
class AnotherException(Exception):
pass
+
response = DummyResponse()
exception_response = DummyResponse()
exception_response.app_iter = ["Hello, world"]
@@ -919,8 +1091,13 @@
exception_view = DummyView(exception_response)
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, None)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, AnotherException)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ AnotherException,
+ )
router = self._makeOne()
start_response = DummyStartResponse()
self.assertRaises(MyException, router, environ, start_response)
@@ -929,14 +1106,21 @@
from pyramid.interfaces import IRootFactory
from pyramid.interfaces import IRequest
from pyramid.interfaces import IExceptionViewClassifier
+
def rootfactory(request):
raise RuntimeError()
+
self.registry.registerUtility(rootfactory, IRootFactory)
exception_response = DummyResponse()
exception_response.app_iter = ["Hello, world"]
exception_view = DummyView(exception_response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ RuntimeError,
+ )
environ = self._makeEnviron()
router = self._makeOne()
start_response = DummyStartResponse()
@@ -946,14 +1130,20 @@
def test_traverser_raises_exception_view(self):
from pyramid.interfaces import IRequest
from pyramid.interfaces import IExceptionViewClassifier
+
environ = self._makeEnviron()
context = DummyContext()
self._registerTraverserFactory(context, raise_error=RuntimeError())
exception_response = DummyResponse()
exception_response.app_iter = ["Hello, world"]
exception_view = DummyView(exception_response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ RuntimeError,
+ )
router = self._makeOne()
start_response = DummyStartResponse()
result = router(environ, start_response)
@@ -963,16 +1153,22 @@
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
+
environ = self._makeEnviron()
response = DummyResponse()
view = DummyView(response, raise_exception=RuntimeError)
-
- self._registerView(self.config.derive_view(view), '',
- IViewClassifier, IRequest, None)
+
+ self._registerView(
+ self.config.derive_view(view), '', IViewClassifier, IRequest, None
+ )
exception_view = DummyView(None)
- self._registerView(self.config.derive_view(exception_view), '',
- IExceptionViewClassifier,
- IRequest, RuntimeError)
+ self._registerView(
+ self.config.derive_view(exception_view),
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ RuntimeError,
+ )
router = self._makeOne()
start_response = DummyStartResponse()
self.assertRaises(ValueError, router, environ, start_response)
@@ -980,6 +1176,7 @@
def test_call_route_raises_route_exception_view(self):
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
+
req_iface = self._registerRouteRequest('foo')
self._connectRoute('foo', 'archives/:action/:article', None)
view = DummyView(DummyResponse(), raise_exception=RuntimeError)
@@ -987,8 +1184,13 @@
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view = DummyView(response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- req_iface, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ req_iface,
+ RuntimeError,
+ )
environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
start_response = DummyStartResponse()
router = self._makeOne()
@@ -999,6 +1201,7 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
req_iface = self._registerRouteRequest('foo')
self._connectRoute('foo', 'archives/:action/:article', None)
view = DummyView(DummyResponse(), raise_exception=RuntimeError)
@@ -1006,8 +1209,13 @@
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view = DummyView(response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- req_iface, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ req_iface,
+ RuntimeError,
+ )
environ = self._makeEnviron()
start_response = DummyStartResponse()
router = self._makeOne()
@@ -1017,6 +1225,7 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
req_iface = self._registerRouteRequest('foo')
self._connectRoute('foo', 'archives/:action/:article', None)
view = DummyView(DummyResponse(), raise_exception=RuntimeError)
@@ -1024,8 +1233,13 @@
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view = DummyView(response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ RuntimeError,
+ )
environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
start_response = DummyStartResponse()
router = self._makeOne()
@@ -1036,10 +1250,13 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
class SuperException(Exception):
pass
+
class SubException(SuperException):
pass
+
req_iface = self._registerRouteRequest('foo')
self._connectRoute('foo', 'archives/:action/:article', None)
view = DummyView(DummyResponse(), raise_exception=SuperException)
@@ -1047,8 +1264,13 @@
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view = DummyView(response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, SubException)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ SubException,
+ )
environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
start_response = DummyStartResponse()
router = self._makeOne()
@@ -1058,10 +1280,13 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
class SuperException(Exception):
pass
+
class SubException(SuperException):
pass
+
req_iface = self._registerRouteRequest('foo')
self._connectRoute('foo', 'archives/:action/:article', None)
view = DummyView(DummyResponse(), raise_exception=SubException)
@@ -1069,8 +1294,13 @@
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view = DummyView(response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, SuperException)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ SuperException,
+ )
environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
start_response = DummyStartResponse()
router = self._makeOne()
@@ -1081,10 +1311,13 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
class MyException(Exception):
pass
+
class AnotherException(Exception):
pass
+
req_iface = self._registerRouteRequest('foo')
self._connectRoute('foo', 'archives/:action/:article', None)
view = DummyView(DummyResponse(), raise_exception=MyException)
@@ -1092,8 +1325,13 @@
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view = DummyView(response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, AnotherException)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ AnotherException,
+ )
environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
start_response = DummyStartResponse()
router = self._makeOne()
@@ -1103,6 +1341,7 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
req_iface = self._registerRouteRequest('foo')
self._connectRoute('foo', 'archives/:action/:article', None)
view = DummyView(DummyResponse(), raise_exception=RuntimeError)
@@ -1110,13 +1349,23 @@
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view = DummyView(response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- IRequest, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ IRequest,
+ RuntimeError,
+ )
response_spec = DummyResponse()
response_spec.app_iter = ["Hello, special world"]
exception_view_spec = DummyView(response_spec)
- self._registerView(exception_view_spec, '', IExceptionViewClassifier,
- req_iface, RuntimeError)
+ self._registerView(
+ exception_view_spec,
+ '',
+ IExceptionViewClassifier,
+ req_iface,
+ RuntimeError,
+ )
environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
start_response = DummyStartResponse()
router = self._makeOne()
@@ -1126,6 +1375,7 @@
def test_call_route_raises_exception_view_another_route(self):
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
+
req_iface = self._registerRouteRequest('foo')
another_req_iface = self._registerRouteRequest('bar')
self._connectRoute('foo', 'archives/:action/:article', None)
@@ -1134,8 +1384,13 @@
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view = DummyView(response)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- another_req_iface, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ another_req_iface,
+ RuntimeError,
+ )
environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
start_response = DummyStartResponse()
router = self._makeOne()
@@ -1145,6 +1400,7 @@
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
+
req_iface = self._registerRouteRequest('foo')
response = DummyResponse()
exception_response = DummyResponse()
@@ -1153,8 +1409,13 @@
exception_view = DummyView(exception_response)
environ = self._makeEnviron()
self._registerView(view, '', IViewClassifier, IRequest, None)
- self._registerView(exception_view, '', IExceptionViewClassifier,
- req_iface, RuntimeError)
+ self._registerView(
+ exception_view,
+ '',
+ IExceptionViewClassifier,
+ req_iface,
+ RuntimeError,
+ )
router = self._makeOne()
start_response = DummyStartResponse()
self.assertRaises(RuntimeError, router, environ, start_response)
@@ -1163,6 +1424,7 @@
from pyramid.exceptions import PredicateMismatch
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IRequest
+
view = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
self._registerView(view, '', IViewClassifier, IRequest, None)
environ = self._makeEnviron()
@@ -1175,21 +1437,30 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IRequest, IResponse
from pyramid.response import Response
+
class BaseContext:
pass
+
class DummyContext(BaseContext):
pass
+
context = DummyContext()
self._registerTraverserFactory(context)
view = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
- self._registerView(view, '', IViewClassifier, IRequest,
- DummyContext)
+ self._registerView(view, '', IViewClassifier, IRequest, DummyContext)
good_view = DummyView('abc')
- self._registerView(self.config.derive_view(good_view),
- '', IViewClassifier, IRequest, BaseContext)
+ self._registerView(
+ self.config.derive_view(good_view),
+ '',
+ IViewClassifier,
+ IRequest,
+ BaseContext,
+ )
router = self._makeOne()
+
def make_response(s):
return Response(s)
+
router.registry.registerAdapter(make_response, (str,), IResponse)
environ = self._makeEnviron()
start_response = DummyStartResponse()
@@ -1202,27 +1473,36 @@
from pyramid.interfaces import IRequest, IResponse
from pyramid.response import Response
from zope.interface import Interface, implementer
+
class IBaseContext(Interface):
pass
+
class IContext(IBaseContext):
pass
+
@implementer(IContext)
class DummyContext:
pass
+
context = DummyContext()
self._registerTraverserFactory(context)
view1 = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
- self._registerView(view1, '', IViewClassifier, IRequest,
- DummyContext)
+ self._registerView(view1, '', IViewClassifier, IRequest, DummyContext)
view2 = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
- self._registerView(view2, '', IViewClassifier, IRequest,
- IContext)
+ self._registerView(view2, '', IViewClassifier, IRequest, IContext)
good_view = DummyView('abc')
- self._registerView(self.config.derive_view(good_view),
- '', IViewClassifier, IRequest, IBaseContext)
+ self._registerView(
+ self.config.derive_view(good_view),
+ '',
+ IViewClassifier,
+ IRequest,
+ IBaseContext,
+ )
router = self._makeOne()
+
def make_response(s):
return Response(s)
+
router.registry.registerAdapter(make_response, (str,), IResponse)
environ = self._makeEnviron()
start_response = DummyStartResponse()
@@ -1234,21 +1514,29 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IRequest
from zope.interface import Interface, implementer
+
class IContext(Interface):
pass
+
class IOtherContext(Interface):
pass
+
@implementer(IContext)
class DummyContext:
pass
+
context = DummyContext()
self._registerTraverserFactory(context)
view = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
- self._registerView(view, '', IViewClassifier, IRequest,
- DummyContext)
+ self._registerView(view, '', IViewClassifier, IRequest, DummyContext)
please_dont_call_me_view = DummyView('abc')
- self._registerView(self.config.derive_view(please_dont_call_me_view),
- '', IViewClassifier, IRequest, IOtherContext)
+ self._registerView(
+ self.config.derive_view(please_dont_call_me_view),
+ '',
+ IViewClassifier,
+ IRequest,
+ IOtherContext,
+ )
router = self._makeOne()
environ = self._makeEnviron()
router = self._makeOne()
@@ -1259,9 +1547,12 @@
from pyramid.interfaces import IExecutionPolicy
from pyramid.request import Request
from pyramid.response import Response
+
registry = self.config.registry
+
def dummy_policy(environ, router):
return Response(status=200, body=b'foo')
+
registry.registerUtility(dummy_policy, IExecutionPolicy)
router = self._makeOne()
resp = Request.blank('/').get_response(router)
@@ -1272,23 +1563,29 @@
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IExceptionViewClassifier
from pyramid.interfaces import IRequest
+
class Exception1(Exception):
pass
+
class Exception2(Exception):
pass
+
req_iface = self._registerRouteRequest('foo')
self._connectRoute('foo', 'archives/:action/:article', None)
view = DummyView(DummyResponse(), raise_exception=Exception1)
self._registerView(view, '', IViewClassifier, req_iface, None)
- exception_view1 = DummyView(DummyResponse(),
- raise_exception=Exception2)
- self._registerView(exception_view1, '', IExceptionViewClassifier,
- IRequest, Exception1)
+ exception_view1 = DummyView(
+ DummyResponse(), raise_exception=Exception2
+ )
+ self._registerView(
+ exception_view1, '', IExceptionViewClassifier, IRequest, Exception1
+ )
response = DummyResponse()
response.app_iter = ["Hello, world"]
exception_view2 = DummyView(response)
- self._registerView(exception_view2, '', IExceptionViewClassifier,
- IRequest, Exception2)
+ self._registerView(
+ exception_view2, '', IExceptionViewClassifier, IRequest, Exception2
+ )
environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
start_response = DummyStartResponse()
router = self._makeOne()
@@ -1300,13 +1597,16 @@
from pyramid.interfaces import IExecutionPolicy
from pyramid.request import Request
from pyramid.response import Response
+
registry = self.config.registry
result = []
+
def dummy_policy(environ, router):
with router.request_context(environ):
result.append(get_current_request())
result.append(get_current_request())
return Response(status=200, body=b'foo')
+
registry.registerUtility(dummy_policy, IExecutionPolicy)
router = self._makeOne()
resp = Request.blank('/test_path').get_response(router)
@@ -1320,8 +1620,10 @@
from pyramid.interfaces import IExecutionPolicy
from pyramid.request import Request
from pyramid.response import Response
+
registry = self.config.registry
result = []
+
def dummy_policy(environ, router):
ctx = router.request_context(environ)
ctx.begin()
@@ -1329,6 +1631,7 @@
ctx.end()
result.append(get_current_request())
return Response(status=200, body=b'foo')
+
registry.registerUtility(dummy_policy, IExecutionPolicy)
router = self._makeOne()
resp = Request.blank('/test_path').get_response(router)
@@ -1337,14 +1640,18 @@
self.assertEqual(result[0].path_info, '/test_path')
self.assertEqual(result[1], None)
+
class DummyPredicate(object):
def __call__(self, info, request):
return True
+
def text(self):
return 'predicate'
+
class DummyContext:
pass
+
class DummyView:
def __init__(self, response, raise_exception=None):
@@ -1358,6 +1665,7 @@
raise self.raise_exception
return self.response
+
class DummyRootFactory:
def __init__(self, root):
self.root = root
@@ -1365,21 +1673,26 @@
def __call__(self, environ):
return self.root
+
class DummyStartResponse:
status = ()
headers = ()
+
def __call__(self, status, headers):
self.status = status
self.headers = headers
+
from pyramid.interfaces import IResponse
from zope.interface import implementer
+
@implementer(IResponse)
class DummyResponse(object):
headerlist = ()
app_iter = ()
environ = None
+
def __init__(self, status='200 OK'):
self.status = status
@@ -1387,17 +1700,22 @@
self.environ = environ
start_response(self.status, self.headerlist)
return self.app_iter
-
+
+
class DummyAuthenticationPolicy:
pass
+
class DummyLogger:
def __init__(self):
self.messages = []
+
def info(self, msg):
self.messages.append(msg)
+
warn = info
debug = info
+
def exc_raised(exc, func, *arg, **kw):
try:
@@ -1405,6 +1723,4 @@
except exc as e:
return e
else:
- raise AssertionError('%s not raised' % exc) # pragma: no cover
-
-
+ raise AssertionError('%s not raised' % exc) # pragma: no cover
--
Gitblit v1.9.3