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, '_')