def request(self, **request): """ Similar to parent class, but returns the request object as soon as it has created it. """ environ = { 'HTTP_COOKIE': self.cookies.output(header='', sep='; '), 'PATH_INFO': '/', 'QUERY_STRING': '', 'REMOTE_ADDR': '127.0.0.1', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'SERVER_NAME': 'testserver', 'SERVER_PORT': '80', 'SERVER_PROTOCOL': 'HTTP/1.1', 'wsgi.version': (1,0), 'wsgi.url_scheme': 'http', 'wsgi.errors': self.errors, 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, } environ.update(self.defaults) environ.update(request) request = WSGIRequest(environ) # Add request.user. handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def test_is_authenticated(self): auth = DjangoAuthentication() request = self.factory.get("/") # load the middleware since django doesnt... from django.core.handlers.base import BaseHandler handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: self.assertIsNone(middleware_method(request)) # not logged in should fail self.assertFalse(auth.is_authenticated(request)) # not logged in should be AnonymousUser self.assertEquals(auth.get_identifier(request), "AnonymousUser") # login test user from django.contrib.auth import authenticate, login user = authenticate(username="******", password="******") self.assertIsNotNone(user) login(request, user) # logged in should succeed self.assertTrue(auth.is_authenticated(request)) # should be janeroe logged in self.assertEquals(auth.get_identifier(request), "janeroe")
class MessageSenderWorker(QueueProcessingWorker): def __init__(self): # type: () -> None super().__init__() self.redis_client = get_redis_client() self.handler = BaseHandler() self.handler.load_middleware() def consume(self, event): # type: (Mapping[str, Any]) -> None server_meta = event['server_meta'] environ = { 'REQUEST_METHOD': 'SOCKET', 'SCRIPT_NAME': '', 'PATH_INFO': '/json/messages', 'SERVER_NAME': '127.0.0.1', 'SERVER_PORT': 9993, 'SERVER_PROTOCOL': 'ZULIP_SOCKET/1.0', 'wsgi.version': (1, 0), 'wsgi.input': StringIO(), 'wsgi.errors': sys.stderr, 'wsgi.multithread': False, 'wsgi.multiprocess': True, 'wsgi.run_once': False, 'zulip.emulated_method': 'POST' } if 'socket_user_agent' in event['request']: environ['HTTP_USER_AGENT'] = event['request']['socket_user_agent'] del event['request']['socket_user_agent'] # We're mostly using a WSGIRequest for convenience environ.update(server_meta['request_environ']) request = WSGIRequest(environ) # Note: If we ever support non-POST methods, we'll need to change this. request._post = event['request'] request.csrf_processing_done = True user_profile = get_user_profile_by_id(server_meta['user_id']) request._cached_user = user_profile resp = self.handler.get_response(request) server_meta['time_request_finished'] = time.time() server_meta['worker_log_data'] = request._log_data resp_content = resp.content.decode('utf-8') response_data = ujson.loads(resp_content) if response_data['result'] == 'error': check_and_send_restart_signal() result = {'response': response_data, 'req_id': event['req_id'], 'server_meta': server_meta} redis_key = req_redis_key(event['req_id']) self.redis_client.hmset(redis_key, {'status': 'complete', 'response': resp_content}) queue_json_publish(server_meta['return_queue'], result, respond_send_message)
def dummy_request(self): """ Construct a HttpRequest object that is, as far as possible, representative of ones that would receive this page as a response. Used for previewing / moderation and any other place where we want to display a view of this page in the admin interface without going through the regular page routing logic. """ url = self.full_url if url: url_info = urlparse(url) hostname = url_info.netloc path = url_info.path port = url_info.port or 80 else: hostname = 'example.com' path = '/' port = 80 request = WSGIRequest({ 'REQUEST_METHOD': 'GET', 'PATH_INFO': path, 'SERVER_NAME': hostname, 'SERVER_PORT': port, 'wsgi.input': StringIO(), }) # Apply middleware to the request - see http://www.mellowmorning.com/2011/04/18/mock-django-request-for-testing/ handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request_args): """Constructs a generic request object, INCLUDING middleware modifications.""" from django.core import urlresolvers request = RequestFactory.request(self, **request_args) ###pprint.pprint(request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: #print("APPLYING REQUEST MIDDLEWARE ", middleware_method, file=sys.stderr) if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware for middleware_method in handler._view_middleware: #print("APPLYING VIEW MIDDLEWARE ", middleware_method, file=sys.stderr) response = middleware_method(request, callback, callback_args, callback_kwargs) if response: raise Exception("Couldn't create request mock object - " "view middleware returned a response") return request
def _prepare_request(self, request, page, user, lang, use_middlewares, use_toolbar=False): request.current_page = SimpleLazyObject(lambda: page) if not user: if self._login_context: user = self._login_context.user else: user = AnonymousUser() request.user = user request.session = {} request.cookies = SimpleCookie() request.errors = StringIO() request.LANGUAGE_CODE = lang # Let's use middleware in case requested, otherwise just use CMS toolbar if needed if use_middlewares: handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception(u'Couldn\'t create request mock object -' u'request middleware returned a response') elif use_toolbar: from cms.middleware.toolbar import ToolbarMiddleware mid = ToolbarMiddleware() mid.process_request(request) return request
def test_error_handlers(rf): """ Test that SHOOP_FRONT_INSTALL_ERROR_HANDLERS installs error handlers without overwriting possible custom ones. """ with override_settings( DEBUG=False, SHOOP_FRONT_INSTALL_ERROR_HANDLERS=True, MIDDLEWARE_CLASSES=[] ): with replace_urls([ url("^aaargh/", errorful_view) ], {"handler404": four_oh_four}): resolver = get_resolver(None) urlconf = resolver.urlconf_module install_error_handlers() assert callable(urlconf.handler500) # We get a new 500 handler assert urlconf.handler404 == four_oh_four # Our custom 404 handler didn't get overwritten handler = BaseHandler() handler.load_middleware() # Test 500 response = handler.get_response(rf.get("/aaargh/")) assert response.status_code == 500 # Uh oh! assert isinstance(response, TemplateResponse) # Looks good! assert response.template_name.startswith("shoop") # Woop! # Test 404 response = handler.get_response(rf.get("/another_castle/")) assert response.status_code == 200 # Our custom 404 handler made it a 200! assert b"flesh wound" in response.content
def request(self, **request): """ Similar to parent class, but returns the request object as soon as it has created it. """ environ = { 'HTTP_COOKIE': self.cookies, 'PATH_INFO': '/', 'QUERY_STRING': '', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, 'SERVER_PROTOCOL': 'HTTP/1.1', } environ.update(self.defaults) environ.update(request) request = WSGIRequest(environ) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): """ Similar to parent class, but returns the request object as soon as it has created it. """ environ = { 'HTTP_COOKIE': self.cookies, 'PATH_INFO': '/', 'QUERY_STRING': '', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, 'SERVER_PROTOCOL': 'HTTP/1.1', } environ.update(self.defaults) environ.update(request) request = WSGIRequest(environ) # Add request.user. handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def process_response(self, request, response): try: if hasattr(response, 'render') and callable(response.render): return response.render() return response except Exception: import sys from django.conf import settings from django.core.handlers.base import BaseHandler from django.core import signals from django.core import urlresolvers urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) receivers = signals.got_request_exception.send( sender=self.__class__, request=request, ) handler = BaseHandler() return handler.handle_uncaught_exception( request, resolver, sys.exc_info(), )
def request(self, **request): handler = BaseHandler() handler.load_middleware() r = WSGIRequest(self._base_environ(**request)) for middleware_method in handler._request_middleware: if middleware_method(r): raise Exception('error on middleware {}'.format(middleware_method)) return r
def request(self, **request): request = super(RequestFactory, self).request(**request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception('request middleware returned a response') return request
def request(self, **request): request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for mw in handler._request_middleware: if mw(request): raise Exception('middleware returned a reponse') return request
def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None): handler = BaseHandler() handler.load_middleware() wsgi_request = self.prepared_request_to_wsgi_request(request) http_response = handler.get_response(wsgi_request) requests_response = self.http_response_to_response(http_response, request) return requests_response
def request(self, **request): request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): "Construct a generic request object." request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: # pylint: disable=protected-access if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): # https://gist.github.com/tschellenbach/925270 request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): #https://gist.github.com/tschellenbach/925270 request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): "Construct a generic request object." request["REQUEST"] = dict() request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): "Construct a generic request object." request['REQUEST'] = dict() request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): "Construct a generic request object." request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() request.csrf_processing_done = True for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
class MessageSenderWorker(QueueProcessingWorker): def __init__(self): # type: () -> None super(MessageSenderWorker, self).__init__() self.redis_client = get_redis_client() self.handler = BaseHandler() self.handler.load_middleware() def consume(self, event): # type: (Mapping[str, Any]) -> None server_meta = event['server_meta'] environ = { 'REQUEST_METHOD': 'SOCKET', 'SCRIPT_NAME': '', 'PATH_INFO': '/json/messages', 'SERVER_NAME': 'localhost', 'SERVER_PORT': 9993, 'SERVER_PROTOCOL': 'ZULIP_SOCKET/1.0', 'wsgi.version': (1, 0), 'wsgi.input': StringIO(), 'wsgi.errors': sys.stderr, 'wsgi.multithread': False, 'wsgi.multiprocess': True, 'wsgi.run_once': False, 'zulip.emulated_method': 'POST' } # We're mostly using a WSGIRequest for convenience environ.update(server_meta['request_environ']) request = WSGIRequest(environ) request._request = event['request'] request.csrf_processing_done = True user_profile = get_user_profile_by_id(server_meta['user_id']) request._cached_user = user_profile resp = self.handler.get_response(request) server_meta['time_request_finished'] = time.time() server_meta['worker_log_data'] = request._log_data resp_content = resp.content.decode('utf-8') result = { 'response': ujson.loads(resp_content), 'req_id': event['req_id'], 'server_meta': server_meta } redis_key = req_redis_key(event['req_id']) self.redis_client.hmset(redis_key, { 'status': 'complete', 'response': resp_content }) queue_json_publish(server_meta['return_queue'], result, lambda e: None)
def request(self, **request): request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() # call each middleware in turn and throw away any responses that they might return for middleware_path in settings.MIDDLEWARE: middleware = import_string(middleware_path)(handler) if hasattr(middleware, 'process_request'): middleware.process_request(request) return request
def test_jwt_refresh_token_middleware(rf, customer_user, settings): refresh_token = create_refresh_token(customer_user) settings.MIDDLEWARE = [ "saleor.core.middleware.jwt_refresh_token_middleware", ] request = rf.request() request.refresh_token = refresh_token handler = BaseHandler() handler.load_middleware() response = handler.get_response(request) cookie = response.cookies.get(JWT_REFRESH_TOKEN_COOKIE_NAME) assert cookie.value == refresh_token
def make_request(self, url, with_middleware=False): request = self.request_factory.get(url) # see comments at http://djangosnippets.org/snippets/963/ if with_middleware: handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def __init__(self, *args, **kwargs): # create django request resolver self.handler = BaseHandler() # prevent recursive includes old = settings.MIDDLEWARE name = self.__module__ + '.' + self.__class__.__name__ settings.MIDDLEWARE = [i for i in settings.MIDDLEWARE if i != name] self.handler.load_middleware() settings.MIDDLEWARE = old super(CommonMiddlewareAppendSlashWithoutRedirect, self).__init__(*args, **kwargs)
def test_jwt_refresh_token_middleware_samesite_debug_mode(rf, customer_user, settings): refresh_token = create_refresh_token(customer_user) settings.MIDDLEWARE = [ "saleor.core.middleware.jwt_refresh_token_middleware", ] settings.DEBUG = True request = rf.request() request.refresh_token = refresh_token handler = BaseHandler() handler.load_middleware() response = handler.get_response(request) cookie = response.cookies.get(JWT_REFRESH_TOKEN_COOKIE_NAME) assert cookie["samesite"] == "Lax"
def request(self, **request): "Construct a generic request object." request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() # BaseHandler_request_middleware is not set in Django2.0 # and removed in Django2.1 if sys.version_info[0] < 2: for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def initialize_context() -> HttpRequest: """Prepare a request object for webhook subscription. It creates a dummy request object and initialize middleware on it. It is required to process a request in the same way as API logic does. return: HttpRequest """ handler = BaseHandler() context = RequestFactory().request(SERVER_NAME=SimpleLazyObject(get_host)) handler.load_middleware() response = handler.get_response(context) if not response.status_code == 200: raise Exception("Unable to initialize context for webhook.") return context
def get_request_mock(): """Build a ``request`` mock that can be used for testing.""" basehandler = BaseHandler() basehandler.load_middleware() request = WSGIRequest( {"REQUEST_METHOD": "GET", "SERVER_NAME": "test", "SERVER_PORT": "8000", "HTTP_HOST": "testhost"} ) # Apply request middleware for middleware_method in basehandler._request_middleware: # LocaleMiddleware should never be applied a second time because # it would broke the current real request language if "LocaleMiddleware" not in str(middleware_method.im_class): response = middleware_method(request) return request
class UrlConsumer(object): """ Dispatches channel HTTP requests into django's URL system. """ def __init__(self): self.handler = BaseHandler() self.handler.load_middleware() def __call__(self, channel, **kwargs): request = HttpRequest.channel_decode(kwargs) try: response = self.handler.get_response(request) except HttpResponse.ResponseLater: return Channel(request.response_channel).send(**response.channel_encode())
class UrlConsumer(object): """ Dispatches channel HTTP requests into django's URL system. """ def __init__(self): self.handler = BaseHandler() self.handler.load_middleware() def __call__(self, message): request = HttpRequest.channel_decode(message.content) try: response = self.handler.get_response(request) except HttpResponse.ResponseLater: return message.reply_channel.send(response.channel_encode())
def get_request_mock(): """Build a request mock that can be used for testing.""" bh = BaseHandler() bh.load_middleware() request = WSGIRequest({ 'REQUEST_METHOD': 'GET', 'SERVER_NAME': 'test', 'SERVER_PORT': '8000', }) # Apply request middleware for middleware_method in bh._request_middleware: # LocaleMiddleware should never be applied a second time because # it would broke the current real request language if 'LocaleMiddleware' not in str(middleware_method.im_class): response = middleware_method(request) return request
class CommonMiddlewareAppendSlashWithoutRedirect(CommonMiddleware): """ This class converts HttpSmartRedirectResponse to the common response of Django view, without redirect. This is necessary to match status_codes for urls like /url?q=1 and /url/?q=1. If you don't use it, you will have 302 code always on pages without slash. """ response_redirect_class = HttpSmartRedirectResponse def __init__(self, *args, **kwargs): # create django request resolver self.handler = BaseHandler() # prevent recursive includes old = settings.MIDDLEWARE name = self.__module__ + '.' + self.__class__.__name__ settings.MIDDLEWARE = [i for i in settings.MIDDLEWARE if i != name] self.handler.load_middleware() settings.MIDDLEWARE = old super(CommonMiddlewareAppendSlashWithoutRedirect, self).__init__(*args, **kwargs) def get_full_path_with_slash(self, request): """ Return the full path of the request with a trailing slash appended without Exception in Debug mode """ new_path = request.get_full_path(force_append_slash=True) # Prevent construction of scheme relative urls. new_path = escape_leading_slashes(new_path) return new_path def process_response(self, request, response): response = super(CommonMiddlewareAppendSlashWithoutRedirect, self).process_response(request, response) request.editor_keymap = settings.EDITOR_KEYMAP if isinstance(response, HttpSmartRedirectResponse): if not request.path.endswith('/'): # remove prefix SCRIPT_NAME path = request.path[len(settings.FORCE_SCRIPT_NAME):] if settings.FORCE_SCRIPT_NAME \ else request.path request.path = path + '/' # we don't need query string in path_info because it's in request.GET already request.path_info = request.path response = self.handler.get_response(request) return response
class MessageSenderWorker(QueueProcessingWorker): def __init__(self): # type: () -> None super(MessageSenderWorker, self).__init__() self.redis_client = get_redis_client() self.handler = BaseHandler() self.handler.load_middleware() def consume(self, event): # type: (Mapping[str, Any]) -> None server_meta = event['server_meta'] environ = {'REQUEST_METHOD': 'SOCKET', 'SCRIPT_NAME': '', 'PATH_INFO': '/json/messages', 'SERVER_NAME': 'localhost', 'SERVER_PORT': 9993, 'SERVER_PROTOCOL': 'ZULIP_SOCKET/1.0', 'wsgi.version': (1, 0), 'wsgi.input': StringIO(), 'wsgi.errors': sys.stderr, 'wsgi.multithread': False, 'wsgi.multiprocess': True, 'wsgi.run_once': False, 'zulip.emulated_method': 'POST'} # We're mostly using a WSGIRequest for convenience environ.update(server_meta['request_environ']) request = WSGIRequest(environ) request._request = event['request'] request.csrf_processing_done = True user_profile = get_user_profile_by_id(server_meta['user_id']) request._cached_user = user_profile resp = self.handler.get_response(request) server_meta['time_request_finished'] = time.time() server_meta['worker_log_data'] = request._log_data resp_content = resp.content.decode('utf-8') result = {'response': ujson.loads(resp_content), 'req_id': event['req_id'], 'server_meta': server_meta} redis_key = req_redis_key(event['req_id']) self.redis_client.hmset(redis_key, {'status': 'complete', 'response': resp_content}); queue_json_publish(server_meta['return_queue'], result, lambda e: None)
class Middleware404View(Buildable404View): def __init__(self, **kwargs): self.handler = BaseHandler() self.handler.load_middleware() super().__init__(**kwargs) def get(self, request): return self.handler.get_response(request) def get_content(self): response = self.get(self.request) if hasattr(response, 'render'): return response.render().content if hasattr(response, 'content'): return response.content raise AttributeError( "'%s' object has no attribute 'render' or 'content'" % response)
def _apply_middlewares(self, request): handler = BaseHandler() from django.utils.module_loading import import_string for middleware_path in reversed(settings.MIDDLEWARE): middleware = import_string(middleware_path) mw_instance = middleware(handler) if hasattr(mw_instance, 'process_request'): mw_instance.process_request(request)
def get_events_backend( request: HttpRequest, user_profile: UserProfile, handler: BaseHandler, user_client: Optional[Client] = REQ(converter=get_client, default=None), last_event_id: Optional[int] = REQ(converter=int, default=None), queue_id: Optional[List[str]] = REQ(default=None), apply_markdown: bool = REQ(default=False, validator=check_bool), client_gravatar: bool = REQ(default=False, validator=check_bool), all_public_streams: bool = REQ(default=False, validator=check_bool), event_types: Optional[str] = REQ(default=None, validator=check_list(check_string)), dont_block: bool = REQ(default=False, validator=check_bool), narrow: Iterable[Sequence[str]] = REQ(default=[], validator=check_list(None)), lifespan_secs: int = REQ(default=0, converter=int) ) -> Union[HttpResponse, _RespondAsynchronously]: if user_client is None: valid_user_client = request.client else: valid_user_client = user_client events_query = dict(user_profile_id=user_profile.id, user_profile_email=user_profile.email, queue_id=queue_id, last_event_id=last_event_id, event_types=event_types, client_type_name=valid_user_client.name, all_public_streams=all_public_streams, lifespan_secs=lifespan_secs, narrow=narrow, dont_block=dont_block, handler_id=handler.handler_id) if queue_id is None: events_query['new_queue_data'] = dict( user_profile_id=user_profile.id, realm_id=user_profile.realm_id, user_profile_email=user_profile.email, event_types=event_types, client_type_name=valid_user_client.name, apply_markdown=apply_markdown, client_gravatar=client_gravatar, all_public_streams=all_public_streams, queue_timeout=lifespan_secs, last_connection_time=time.time(), narrow=narrow) result = fetch_events(events_query) if "extra_log_data" in result: request._log_data['extra'] = result["extra_log_data"] if result["type"] == "async": handler._request = request return RespondAsynchronously if result["type"] == "error": raise result["exception"] return json_success(result["response"])
class MessageSenderWorker(QueueProcessingWorker): def __init__(self): super(MessageSenderWorker, self).__init__() self.redis_client = get_redis_client() self.handler = BaseHandler() self.handler.load_middleware() def consume(self, event): server_meta = event["server_meta"] environ = { "REQUEST_METHOD": "SOCKET", "SCRIPT_NAME": "", "PATH_INFO": "/json/messages", "SERVER_NAME": "localhost", "SERVER_PORT": 9993, "SERVER_PROTOCOL": "ZULIP_SOCKET/1.0", "wsgi.version": (1, 0), "wsgi.input": StringIO(), "wsgi.errors": sys.stderr, "wsgi.multithread": False, "wsgi.multiprocess": True, "wsgi.run_once": False, "zulip.emulated_method": "POST", } # We're mostly using a WSGIRequest for convenience environ.update(server_meta["request_environ"]) request = WSGIRequest(environ) request._request = event["request"] request.csrf_processing_done = True user_profile = get_user_profile_by_id(server_meta["user_id"]) request._cached_user = user_profile resp = self.handler.get_response(request) server_meta["time_request_finished"] = time.time() server_meta["worker_log_data"] = request._log_data resp_content = resp.content result = {"response": ujson.loads(resp_content), "req_id": event["req_id"], "server_meta": server_meta} redis_key = req_redis_key(event["req_id"]) self.redis_client.hmset(redis_key, {"status": "complete", "response": resp_content}) queue_json_publish(server_meta["return_queue"], result, lambda e: None)
def _prepare_request(self, request, page, user, lang, use_middlewares, use_toolbar=False, secure=False): from django.contrib.auth.models import AnonymousUser try: from importlib import import_module except ImportError: from django.utils.importlib import import_module engine = import_module(settings.SESSION_ENGINE) request.current_page = SimpleLazyObject(lambda: page) if not user: if self._login_context: user = self._login_context.user else: user = AnonymousUser() if user.is_authenticated(): session_key = user._meta.pk.value_to_string(user) else: session_key = 'session_key' request.user = user request._cached_user = user request.session = engine.SessionStore(session_key) if secure: request.environ['SERVER_PORT'] = str('443') request.environ['wsgi.url_scheme'] = str('https') request.cookies = SimpleCookie() request.errors = StringIO() request.LANGUAGE_CODE = lang if request.method == 'POST': request._dont_enforce_csrf_checks = True # Let's use middleware in case requested, otherwise just use CMS toolbar if needed if use_middlewares: handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception('Couldn\'t create request mock object -' 'request middleware returned a response') elif use_toolbar: from cms.middleware.toolbar import ToolbarMiddleware mid = ToolbarMiddleware() mid.process_request(request) return request
def get_request_from_message(self, message, widget, user): """returns inicialized request """ request = AsgiHandler.request_class(message) request.user = user request.path = widget.parent.get_absolute_url() request.frontend_editing = True if not hasattr(request, '_feincms_extra_context'): request._feincms_extra_context = {} # call processors for fn in reversed(list(widget.parent.request_processors.values())): fn(widget.parent, request) request.LEONARDO_CONFIG = ContextConfig(request) # this breaks all get_absolute_uri calls request.META['SERVER_NAME'] = 'localhost' request.META['SERVER_PORT'] = 80 handler = BaseHandler() handler.load_middleware() # Apply request middleware for middleware_method in handler._request_middleware: try: middleware_method(request) except: pass # we know that we are in editing mode and user is logged in request.frontend_editing = True request.user = user # call processors for fn in reversed(list(widget.parent.request_processors.values())): fn(widget.parent, request) if hasattr(widget, 'process') and callable(widget.process): widget.process(request, view=self) return request
def test_kwargs_redirect(self): """if kwargs['next'] is supplied to the view then this is where the redirect goes""" # set up the data post_data = { 'next': 'http://duckduckgo.com/', 'contenttype_pk' : self.ctype.pk, 'object_pk': self.item.pk, } # make a request and hook up the basket request = self.factory.post('/customer/details', post_data) # all the jiggery pokery handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: middleware_method(request) r = basket(request, next='http://jamiecurle.com/') self.assertEqual(r['location'], 'http://jamiecurle.com/')
def get_fake_request(meta): '''Retrieves a fake request using the given request.META. This allows celery tasks to have a "request" to use in code.''' # if the body was cached in the meta, put it back as the wsgi.input if BODY_KEY in meta: meta['wsgi.input'] = FakePayload(meta[BODY_KEY]) # create a basic request using the Django testing framework request = RequestFactory().request(**meta) # run middleware on it handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: response = middleware_method(request) if response: raise Exception("Middleware cannot return a response with a FakeRequest.") # return the request return request
def _prepare_request(self, request, page, user, lang, use_middlewares, use_toolbar=False, secure=False): from django.contrib.auth.models import AnonymousUser request.current_page = SimpleLazyObject(lambda: page) if not user: if self._login_context: user = self._login_context.user else: user = AnonymousUser() request.user = user request._cached_user = user request.session = {} if secure: request.environ['SERVER_PORT'] = str('443') request.environ['wsgi.url_scheme'] = str('https') if user.is_authenticated(): request.session[SESSION_KEY] = user._meta.pk.value_to_string(user) request.cookies = SimpleCookie() request.errors = StringIO() request.LANGUAGE_CODE = lang if request.method == 'POST': request._dont_enforce_csrf_checks = True # Let's use middleware in case requested, otherwise just use CMS toolbar if needed if use_middlewares: handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception('Couldn\'t create request mock object -' 'request middleware returned a response') elif use_toolbar: from cms.middleware.toolbar import ToolbarMiddleware mid = ToolbarMiddleware() mid.process_request(request) return request
def get_request_mock(): """Build a ``request`` mock up that is used in to render the templates in the most fidel environement as possible. This fonction is used in the get_placeholders method to render the input template and search for the placeholder within. """ basehandler = BaseHandler() basehandler.load_middleware() request = FACTORY.get('/') # Apply request middleware for middleware_method in basehandler._request_middleware: # LocaleMiddleware should never be applied a second time because # it would broke the current real request language if 'LocaleMiddleware' not in str(middleware_method.im_class): response = middleware_method(request) return request
def consume_request(self, request, start_callback=None, success_callback=None, fail_callback=None): start_callback() if start_callback else None handler = BaseHandler() handler.load_middleware() response = handler.get_response(request) if is_success(response.status_code): success_callback() if success_callback else None else: fail_callback() if fail_callback else None self.responses[request] = response return True
def get_events_backend(request: HttpRequest, user_profile: UserProfile, handler: BaseHandler, user_client: Optional[Client]=REQ(converter=get_client, default=None), last_event_id: Optional[int]=REQ(converter=int, default=None), queue_id: Optional[List[str]]=REQ(default=None), apply_markdown: bool=REQ(default=False, validator=check_bool), client_gravatar: bool=REQ(default=False, validator=check_bool), all_public_streams: bool=REQ(default=False, validator=check_bool), event_types: Optional[str]=REQ(default=None, validator=check_list(check_string)), dont_block: bool=REQ(default=False, validator=check_bool), narrow: Iterable[Sequence[str]]=REQ(default=[], validator=check_list(None)), lifespan_secs: int=REQ(default=0, converter=int) ) -> Union[HttpResponse, _RespondAsynchronously]: if user_client is None: valid_user_client = request.client else: valid_user_client = user_client events_query = dict( user_profile_id = user_profile.id, user_profile_email = user_profile.email, queue_id = queue_id, last_event_id = last_event_id, event_types = event_types, client_type_name = valid_user_client.name, all_public_streams = all_public_streams, lifespan_secs = lifespan_secs, narrow = narrow, dont_block = dont_block, handler_id = handler.handler_id) if queue_id is None: events_query['new_queue_data'] = dict( user_profile_id = user_profile.id, realm_id = user_profile.realm_id, user_profile_email = user_profile.email, event_types = event_types, client_type_name = valid_user_client.name, apply_markdown = apply_markdown, client_gravatar = client_gravatar, all_public_streams = all_public_streams, queue_timeout = lifespan_secs, last_connection_time = time.time(), narrow = narrow) result = fetch_events(events_query) if "extra_log_data" in result: request._log_data['extra'] = result["extra_log_data"] if result["type"] == "async": handler._request = request return RespondAsynchronously if result["type"] == "error": raise result["exception"] return json_success(result["response"])
def get_fake_request(meta): '''Retrieves a fake request using the given request.META. This allows celery tasks to have a "request" to use in code.''' # if the body was cached in the meta, put it back as the wsgi.input if BODY_KEY in meta: meta['wsgi.input'] = FakePayload(meta[BODY_KEY]) # create a basic request using the Django testing framework request = RequestFactory().request(**meta) # run middleware on it handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: response = middleware_method(request) if response: raise Exception( "Middleware cannot return a response with a FakeRequest.") # return the request return request
def test_jwt_refresh_token_middleware_token_without_expire(rf, customer_user, settings): settings.JWT_EXPIRE = True payload = jwt_user_payload( customer_user, JWT_REFRESH_TYPE, settings.JWT_TTL_REFRESH, ) del payload["exp"] refresh_token = jwt_encode(payload) settings.MIDDLEWARE = [ "saleor.core.middleware.jwt_refresh_token_middleware", ] request = rf.request() request.refresh_token = refresh_token handler = BaseHandler() handler.load_middleware() response = handler.get_response(request) cookie = response.cookies.get(JWT_REFRESH_TOKEN_COOKIE_NAME) assert cookie.value == refresh_token
def test_error_handlers(rf): """ Test that SHUUP_FRONT_INSTALL_ERROR_HANDLERS installs error handlers without overwriting possible custom ones. """ with override_settings( DEBUG=False, SHUUP_FRONT_INSTALL_ERROR_HANDLERS=True, MIDDLEWARE_CLASSES=[], TEMPLATES=[ # Overriden to be sure about the contents of our 500.jinja { "BACKEND": "django_jinja.backend.Jinja2", "DIRS": [ os.path.realpath(os.path.join(os.path.dirname(__file__), "templates")) ], "OPTIONS": { "match_extension": ".jinja", "newstyle_gettext": True, }, "NAME": "jinja2", } ] ): with replace_urls([ url("^aaargh/", errorful_view) ], {"handler404": four_oh_four}): resolver = get_resolver(None) urlconf = resolver.urlconf_module install_error_handlers() assert callable(urlconf.handler500) # We get a new 500 handler assert urlconf.handler404 == four_oh_four # Our custom 404 handler didn't get overwritten handler = BaseHandler() handler.load_middleware() # Test 500 response = handler.get_response(rf.get("/aaargh/")) assert response.status_code == 500 # Uh oh! assert "intergalactic testing 500" in force_text(response.content) # Test 404 response = handler.get_response(rf.get("/another_castle/")) assert response.status_code == 200 # Our custom 404 handler made it a 200! assert b"flesh wound" in response.content
def build_dummy_request(newsitem): """ Construct a HttpRequest object that is, as far as possible, representative of ones that would receive this page as a response. Used for previewing / moderation and any other place where we want to display a view of this page in the admin interface without going through the regular page routing logic. """ url = newsitem.full_url if url: url_info = urlparse(url) hostname = url_info.hostname path = url_info.path port = url_info.port or 80 else: # Cannot determine a URL to this page - cobble one together based on # whatever we find in ALLOWED_HOSTS try: hostname = settings.ALLOWED_HOSTS[0] except IndexError: hostname = 'localhost' path = '/' port = 80 request = WSGIRequest({ 'REQUEST_METHOD': 'GET', 'PATH_INFO': path, 'SERVER_NAME': hostname, 'SERVER_PORT': port, 'HTTP_HOST': hostname, 'wsgi.input': StringIO(), }) # Apply middleware to the request - see http://www.mellowmorning.com/2011/04/18/mock-django-request-for-testing/ handler = BaseHandler() handler.load_middleware() # call each middleware in turn and throw away any responses that they might return for middleware_method in handler._request_middleware: middleware_method(request) return request
def get_request_mock(): """Build a ``request`` mock up that is used in to render the templates in the most fidel environement as possible. This fonction is used in the get_placeholders method to render the input template and search for the placeholder within. """ basehandler = BaseHandler() basehandler.load_middleware() # http://www.python.org/dev/peps/pep-0333/ request = WSGIRequest({ 'HTTP_COOKIE': '', 'PATH_INFO': '/', 'QUERY_STRING': '', 'REMOTE_ADDR': '127.0.0.1', 'REQUEST_METHOD': 'GET', 'SERVER_NAME': 'page-request-mock', 'SCRIPT_NAME': '', 'SERVER_PORT': '80', 'SERVER_PROTOCOL': 'HTTP/1.1', 'HTTP_HOST': 'page-request-host', 'CONTENT_TYPE': 'text/html; charset=utf-8', 'wsgi.version': (1, 0), 'wsgi.url_scheme': 'http', 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, 'wsgi.input': StringIO("") }) # Apply request middleware for middleware_method in basehandler._request_middleware: # LocaleMiddleware should never be applied a second time because # it would broke the current real request language if 'LocaleMiddleware' not in str(middleware_method.im_class): response = middleware_method(request) return request
def get_request_mock(): """Build a ``request`` mock up that is used in to render the templates in the most fidel environement as possible. This fonction is used in the get_placeholders method to render the input template and search for the placeholder within. """ from django.test.client import RequestFactory from django.core.handlers.base import BaseHandler factory = RequestFactory() basehandler = BaseHandler() basehandler.load_middleware() request = factory.get('/') # Apply request middleware for middleware_method in basehandler._request_middleware: # LocaleMiddleware should never be applied a second time because # it would broke the current real request language if 'LocaleMiddleware' not in str(middleware_method.__self__.__class__): middleware_method(request) return request
def process_request(self, request): """Replicates a lot of code from BaseHandler#get_response.""" callback, callback_args, callback_kwargs = resolve(request.path_info) if getattr(callback, 'bypass_middleware', False): # bypass_middleware decorator was used; zero out all # middleware and return the response. handler = BaseHandler() handler._request_middleware = [] handler._view_middleware = [] handler._template_response_middleware = [] handler._response_middleware = [] handler._exception_middleware = [] response = handler._get_response(request) return response
def get_response(self, request): # Set up middleware if needed. We couldn't do this earlier, because # settings weren't available. if self._request_middleware is None: self.initLock.acquire() try: try: # Check that middleware is still uninitialised. if self._request_middleware is None: self.load_middleware() except: # Unload whatever middleware we got self._request_middleware = None raise finally: self.initLock.release() return BaseHandler.get_response(self, request)
def test_plugins_middleware_requestor_in_plugin_when_no_app_and_user_in_req_is_none( rf, settings): settings.MIDDLEWARE = [ "saleor.core.middleware.plugins", ] settings.PLUGINS = ["saleor.plugins.tests.sample_plugins.ActivePlugin"] request = rf.request() request.user = None request.app = None handler = BaseHandler() handler.load_middleware() handler.get_response(request) plugin = request.plugins.all_plugins.pop() assert not plugin.requestor