def test_i18n_before_render_and_request(request_i18n):
"""Test if appropriate methods are being added to both context and request."""
request_i18n.registry.notify(NewRequest(request_i18n))
before_render_event = BeforeRender({'request': request_i18n}, {})
request_i18n.registry.notify(before_render_event)
assert 'localizer' in before_render_event
assert '_' in before_render_event
def make_request(self, *args, **kwds):
req = super(TestMetlog, self).make_request(*args, **kwds)
req.user = {'uid': 'aa'}
req.matchdict = {}
cornice.wrap_request(NewRequest(req))
req.validated["storage"] = get_storage(req)
req.validated["userid"] = req.user["uid"]
return req
def test_does_not_preload_for_opted_out_requests(self, path,
pyramid_request):
pyramid_request.path = path
event = NewRequest(pyramid_request)
preload_flags(event)
assert not event.request.feature.loaded
def _request(self, headers=None):
if headers is None:
request = Request({})
else:
request = Request({}, headers=headers)
request.registry = self.config.registry
event = NewRequest(request)
add_compress_response_callback(event)
response = request.response
request._process_response_callbacks(response)
return response
def test_directive_get_sockjs_manager(self):
self.config.include('pyramid_sockjs')
request = Request(self._environ)
request.registry = self.registry
self.registry.notify(NewRequest(request))
try:
from pyramid.interfaces import IRequestExtensions
extensions = self.registry.getUtility(IRequestExtensions)
request._set_extensions(extensions)
except ImportError:
pass
self.assertTrue(hasattr(request, 'get_sockjs_manager'))
def test_get_session_manager_unknown(self):
request = Request(self._environ)
request.registry = self.registry
self.registry.notify(NewRequest(request))
try:
from pyramid.interfaces import IRequestExtensions
extensions = self.registry.getUtility(IRequestExtensions)
request._set_extensions(extensions)
except ImportError:
pass
self.assertRaises(
KeyError, request.get_sockjs_manager, 'test')
self.config.add_sockjs_route()
self.assertRaises(
KeyError, request.get_sockjs_manager, 'test')
def test_get_session_manager_default(self):
import pyramid_sockjs
self.config.add_sockjs_route()
request = Request(self._environ)
request.registry = self.registry
self.registry.notify(NewRequest(request))
try:
from pyramid.interfaces import IRequestExtensions
extensions = self.registry.getUtility(IRequestExtensions)
request._set_extensions(extensions)
except ImportError:
pass
sm = request.get_sockjs_manager()
self.assertIs(self.registry.__sockjs_managers__[''], sm)
def test_session_manager_route_url(self):
import pyramid_sockjs
name = 'example'
self.config.add_sockjs_route(name, prefix='/chat-service')
self.config.commit()
request = Request(self._environ)
request.registry = self.registry
self.registry.notify(NewRequest(request))
try:
from pyramid.interfaces import IRequestExtensions
extensions = self.registry.getUtility(IRequestExtensions)
request._set_extensions(extensions)
except ImportError:
pass
sm = request.get_sockjs_manager(name)
self.assertEqual(
sm.route_url(request), 'http://example.com/chat-service/')
def test_preloads_feature_flags(self, pyramid_request):
event = NewRequest(pyramid_request)
preload_flags(event)
assert event.request.feature.loaded
def handle_request(self, request):
attrs = request.__dict__
registry = attrs['registry']
request.request_iface = IRequest
context = None
routes_mapper = self.routes_mapper
debug_routematch = self.debug_routematch
adapters = registry.adapters
has_listeners = registry.has_listeners
notify = registry.notify
logger = self.logger
has_listeners and notify(NewRequest(request))
# find the root object
root_factory = self.root_factory
if routes_mapper is not None:
info = routes_mapper(request)
match, route = info['match'], info['route']
if route is None:
if debug_routematch:
msg = 'no route matched for url %s' % request.url
logger and logger.debug(msg)
else:
attrs['matchdict'] = match
attrs['matched_route'] = route
if debug_routematch:
msg = ('route matched for url %s; '
'route_name: %r, '
'path_info: %r, '
'pattern: %r, '
'matchdict: %r, '
'predicates: %r' % (
request.url,
route.name,
request.path_info,
route.pattern,
match,
', '.join([p.text() for p in route.predicates]),
))
logger and logger.debug(msg)
request.request_iface = registry.queryUtility(IRouteRequest,
name=route.name,
default=IRequest)
root_factory = route.factory or self.root_factory
# Notify anyone listening that we are about to start traversal
#
# Notify before creating root_factory in case we want to do something
# special on a route we may have matched. See
# https://github.com/Pylons/pyramid/pull/1876 for ideas of what is
# possible.
has_listeners and notify(BeforeTraversal(request))
# Create the root factory
root = root_factory(request)
attrs['root'] = root
# We are about to traverse and find a context
traverser = adapters.queryAdapter(root, ITraverser)
if traverser is None:
traverser = ResourceTreeTraverser(root)
tdict = traverser(request)
context, view_name, subpath, traversed, vroot, vroot_path = (
tdict['context'],
tdict['view_name'],
tdict['subpath'],
tdict['traversed'],
tdict['virtual_root'],
tdict['virtual_root_path'],
)
attrs.update(tdict)
# Notify anyone listening that we have a context and traversal is
# complete
has_listeners and notify(ContextFound(request))
# find a view callable
context_iface = providedBy(context)
response = _call_view(registry, request, context, context_iface,
view_name)
if response is None:
if self.debug_notfound:
msg = ('debug_notfound of url %s; path_info: %r, '
'context: %r, view_name: %r, subpath: %r, '
'traversed: %r, root: %r, vroot: %r, '
'vroot_path: %r' % (
request.url,
request.path_info,
context,
view_name,
subpath,
traversed,
root,
vroot,
vroot_path,
))
logger and logger.debug(msg)
else:
msg = request.path_info
raise HTTPNotFound(msg)
return response
def attach_analytics(self):
from pyramid.events import NewRequest
# Trigger NewRequest
self.config.testing_add_subscriber(NewRequest)
self.request.registry.notify(NewRequest(self.request))
def handle_request(self, request):
attrs = request.__dict__
registry = attrs['registry']
request.request_iface = IRequest
context = None
routes_mapper = self.routes_mapper
debug_routematch = self.debug_routematch
adapters = registry.adapters
has_listeners = registry.has_listeners
notify = registry.notify
logger = self.logger
has_listeners and notify(NewRequest(request))
# find the root object
root_factory = self.root_factory
if routes_mapper is not None:
info = routes_mapper(request)
match, route = info['match'], info['route']
if route is None:
if debug_routematch:
msg = ('no route matched for url %s' % request.url)
logger and logger.debug(msg)
else:
# TODO: kill off bfg.routes.* environ keys
# when traverser requires request arg, and
# cant cope with environ anymore (they are
# docs-deprecated as of BFG 1.3)
environ = request.environ
environ['bfg.routes.route'] = route
environ['bfg.routes.matchdict'] = match
attrs['matchdict'] = match
attrs['matched_route'] = route
if debug_routematch:
msg = ('route matched for url %s; '
'route_name: %r, '
'path_info: %r, '
'pattern: %r, '
'matchdict: %r, '
'predicates: %r' %
(request.url, route.name, request.path_info,
route.pattern, match, ', '.join(
[p.__text__ for p in route.predicates])))
logger and logger.debug(msg)
request.request_iface = registry.queryUtility(IRouteRequest,
name=route.name,
default=IRequest)
root_factory = route.factory or self.root_factory
root = root_factory(request)
attrs['root'] = root
# find a context
traverser = adapters.queryAdapter(root, ITraverser)
if traverser is None:
traverser = ResourceTreeTraverser(root)
tdict = traverser(request)
context, view_name, subpath, traversed, vroot, vroot_path = (
tdict['context'], tdict['view_name'], tdict['subpath'],
tdict['traversed'], tdict['virtual_root'],
tdict['virtual_root_path'])
attrs.update(tdict)
has_listeners and notify(ContextFound(request))
# find a view callable
context_iface = providedBy(context)
view_callable = adapters.lookup(
(IViewClassifier, request.request_iface, context_iface),
IView,
name=view_name,
default=None)
# invoke the view callable
if view_callable is None:
if self.debug_notfound:
msg = ('debug_notfound of url %s; path_info: %r, '
'context: %r, view_name: %r, subpath: %r, '
'traversed: %r, root: %r, vroot: %r, '
'vroot_path: %r' %
(request.url, request.path_info, context, view_name,
subpath, traversed, root, vroot, vroot_path))
logger and logger.debug(msg)
else:
msg = request.path_info
raise HTTPNotFound(msg)
else:
response = view_callable(context, request)
return response
def __call__(self, environ, start_response):
"""
Accept ``environ`` and ``start_response``; create a
:term:`request` and route the request to a :app:`Pyramid`
view based on introspection of :term:`view configuration`
within the application registry; call ``start_response`` and
return an iterable.
"""
registry = self.registry
adapters = registry.adapters
has_listeners = registry.has_listeners
logger = self.logger
manager = self.threadlocal_manager
request = None
threadlocals = {'registry': registry, 'request': request}
manager.push(threadlocals)
try: # matches finally: manager.pop()
try: # matches finally: ... call request finished callbacks ...
# create the request
request = self.request_factory(environ)
context = None
threadlocals['request'] = request
attrs = request.__dict__
attrs['registry'] = registry
request_iface = IRequest
try: # matches except Exception (exception view execution)
has_listeners and registry.notify(NewRequest(request))
# find the root object
root_factory = self.root_factory
if self.routes_mapper is not None:
info = self.routes_mapper(request)
match, route = info['match'], info['route']
if route is None:
if self.debug_routematch:
msg = ('no route matched for url %s' %
request.url)
logger and logger.debug(msg)
else:
# TODO: kill off bfg.routes.* environ keys when
# traverser requires request arg, and cant cope
# with environ anymore (they are docs-deprecated as
# of BFG 1.3)
environ['bfg.routes.route'] = route
environ['bfg.routes.matchdict'] = match
attrs['matchdict'] = match
attrs['matched_route'] = route
if self.debug_routematch:
msg = ('route matched for url %s; '
'route_name: %r, '
'path_info: %r, '
'pattern: %r, '
'matchdict: %r, '
'predicates: %r' %
(request.url, route.name,
request.path_info, route.pattern,
match, route.predicates))
logger and logger.debug(msg)
request_iface = registry.queryUtility(
IRouteRequest,
name=route.name,
default=IRequest)
root_factory = route.factory or self.root_factory
root = root_factory(request)
attrs['root'] = root
# find a context
traverser = adapters.queryAdapter(root, ITraverser)
if traverser is None:
traverser = ResourceTreeTraverser(root)
tdict = traverser(request)
context, view_name, subpath, traversed, vroot, vroot_path = (
tdict['context'], tdict['view_name'], tdict['subpath'],
tdict['traversed'], tdict['virtual_root'],
tdict['virtual_root_path'])
attrs.update(tdict)
has_listeners and registry.notify(ContextFound(request))
# find a view callable
context_iface = providedBy(context)
view_callable = adapters.lookup(
(IViewClassifier, request_iface, context_iface),
IView,
name=view_name,
default=None)
# invoke the view callable
if view_callable is None:
if self.debug_notfound:
msg = ('debug_notfound of url %s; path_info: %r, '
'context: %r, view_name: %r, subpath: %r, '
'traversed: %r, root: %r, vroot: %r, '
'vroot_path: %r' %
(request.url, request.path_info, context,
view_name, subpath, traversed, root, vroot,
vroot_path))
logger and logger.debug(msg)
else:
msg = request.path_info
raise NotFound(msg)
else:
response = view_callable(context, request)
# handle exceptions raised during root finding and view-exec
except Exception, why:
attrs['exception'] = why
for_ = (IExceptionViewClassifier, request_iface.combined,
providedBy(why))
view_callable = adapters.lookup(for_, IView, default=None)
if view_callable is None:
raise
try:
msg = why[0]
except:
msg = ''
# repoze.bfg.message docs-deprecated in Pyramid 1.0
environ['repoze.bfg.message'] = msg
response = view_callable(why, request)
# process the response
has_listeners and registry.notify(
NewResponse(request, response))
if request.response_callbacks:
request._process_response_callbacks(response)
try:
headers = response.headerlist
app_iter = response.app_iter
status = response.status
except AttributeError:
raise ValueError(
'Non-response object returned from view named %s '
'(and no renderer): %r' % (view_name, response))
finally:
if request is not None and request.finished_callbacks:
request._process_finished_callbacks()
start_response(status, headers)
return app_iter
def handle_request(self, request):
attrs = request.__dict__
registry = attrs['registry']
request.request_iface = IRequest
context = None
routes_mapper = self.routes_mapper
debug_routematch = self.debug_routematch
adapters = registry.adapters
has_listeners = registry.has_listeners
notify = registry.notify
logger = self.logger
has_listeners and notify(NewRequest(request))
# find the root object
root_factory = self.root_factory
if routes_mapper is not None:
info = routes_mapper(request)
match, route = info['match'], info['route']
if route is None:
if debug_routematch:
msg = ('no route matched for url %s' % request.url)
logger and logger.debug(msg)
else:
attrs['matchdict'] = match
attrs['matched_route'] = route
if debug_routematch:
msg = ('route matched for url %s; '
'route_name: %r, '
'path_info: %r, '
'pattern: %r, '
'matchdict: %r, '
'predicates: %r' %
(request.url, route.name, request.path_info,
route.pattern, match, ', '.join(
[p.text() for p in route.predicates])))
logger and logger.debug(msg)
request.request_iface = registry.queryUtility(IRouteRequest,
name=route.name,
default=IRequest)
root_factory = route.factory or self.root_factory
root = root_factory(request)
attrs['root'] = root
# find a context
traverser = adapters.queryAdapter(root, ITraverser)
if traverser is None:
traverser = ResourceTreeTraverser(root)
tdict = traverser(request)
context, view_name, subpath, traversed, vroot, vroot_path = (
tdict['context'], tdict['view_name'], tdict['subpath'],
tdict['traversed'], tdict['virtual_root'],
tdict['virtual_root_path'])
attrs.update(tdict)
has_listeners and notify(ContextFound(request))
# find a view callable
context_iface = providedBy(context)
response = _call_view(registry, request, context, context_iface,
view_name)
if response is None:
if self.debug_notfound:
msg = ('debug_notfound of url %s; path_info: %r, '
'context: %r, view_name: %r, subpath: %r, '
'traversed: %r, root: %r, vroot: %r, '
'vroot_path: %r' %
(request.url, request.path_info, context, view_name,
subpath, traversed, root, vroot, vroot_path))
logger and logger.debug(msg)
else:
msg = request.path_info
raise HTTPNotFound(msg)
return response
def test_fake_before_render(request_fake):
"""Test if appropriate methods are being added to both context and request."""
request_fake.registry.notify(NewRequest(request_fake))
before_render_event = BeforeRender({'request': request_fake}, {})
request_fake.registry.notify(before_render_event)
assert '_' in before_render_event
def test_fake_new_request(request_fake):
"""Test if method are being added to request."""
request_fake.registry.notify(NewRequest(request_fake))
assert hasattr(request_fake, '_')
def handle_request(self, request):
attrs = request.__dict__
registry = attrs['registry']
request.request_iface = IRequest
context = None
routes_mapper = self.routes_mapper
debug_routematch = self.debug_routematch
adapters = registry.adapters
has_listeners = registry.has_listeners
notify = registry.notify
logger = self.logger
has_listeners and notify(NewRequest(request))
# find the root object
root_factory = self.root_factory
if routes_mapper is not None:
info = routes_mapper(request)
match, route = info['match'], info['route']
if route is None:
if debug_routematch:
msg = ('no route matched for url %s' % request.url)
logger and logger.debug(msg)
else:
attrs['matchdict'] = match
attrs['matched_route'] = route
if debug_routematch:
msg = ('route matched for url %s; '
'route_name: %r, '
'path_info: %r, '
'pattern: %r, '
'matchdict: %r, '
'predicates: %r' %
(request.url, route.name, request.path_info,
route.pattern, match, ', '.join(
[p.text() for p in route.predicates])))
logger and logger.debug(msg)
request.request_iface = registry.queryUtility(IRouteRequest,
name=route.name,
default=IRequest)
root_factory = route.factory or self.root_factory
root = root_factory(request)
attrs['root'] = root
# find a context
traverser = adapters.queryAdapter(root, ITraverser)
if traverser is None:
traverser = ResourceTreeTraverser(root)
tdict = traverser(request)
context, view_name, subpath, traversed, vroot, vroot_path = (
tdict['context'], tdict['view_name'], tdict['subpath'],
tdict['traversed'], tdict['virtual_root'],
tdict['virtual_root_path'])
attrs.update(tdict)
has_listeners and notify(ContextFound(request))
# find a view callable
context_iface = providedBy(context)
view_callable = adapters.lookup(
(IViewClassifier, request.request_iface, context_iface),
IView,
name=view_name,
default=None)
# invoke the view callable
if view_callable is None:
if self.debug_notfound:
msg = ('debug_notfound of url %s; path_info: %r, '
'context: %r, view_name: %r, subpath: %r, '
'traversed: %r, root: %r, vroot: %r, '
'vroot_path: %r' %
(request.url, request.path_info, context, view_name,
subpath, traversed, root, vroot, vroot_path))
logger and logger.debug(msg)
else:
msg = request.path_info
raise HTTPNotFound(msg)
else:
try:
response = view_callable(context, request)
except PredicateMismatch:
# look for other views that meet the predicate
# criteria
for iface in context_iface.__sro__[1:]:
previous_view_callable = view_callable
view_callable = adapters.lookup(
(IViewClassifier, request.request_iface, iface),
IView,
name=view_name,
default=None)
# intermediate bases may lookup same view_callable
if view_callable is previous_view_callable:
continue
if view_callable is not None:
try:
response = view_callable(context, request)
break
except PredicateMismatch:
pass
else:
raise
return response
def test_i18n_new_request(request_i18n):
"""Test if method are being added to request."""
request_i18n.registry.notify(NewRequest(request_i18n))
assert isinstance(request_i18n.localizer, Localizer)
assert hasattr(request_i18n, '_')
