def get_request(self, path=None, language=settings.LANGUAGES[0][0]): if not path: path = self.get_pages_root() parsed_path = urlparse(path) host = parsed_path.netloc or 'testserver' port = 80 if ':' in host: host, port = host.split(':', 1) environ = { 'HTTP_COOKIE': self.client.cookies, 'PATH_INFO': parsed_path.path, 'QUERY_STRING': parsed_path.query, 'REMOTE_ADDR': '127.0.0.1', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'SERVER_NAME': host, 'SERVER_PORT': port, 'SERVER_PROTOCOL': 'HTTP/1.1', 'wsgi.version': (1, 0), 'wsgi.url_scheme': 'http', 'wsgi.errors': self.client.errors, 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, 'wsgi.input': '' } request = WSGIRequest(environ) request.session = self.client.session request.user = getattr(self, 'user', AnonymousUser()) request.LANGUAGE_CODE = language return request
def setUp(self): context = {} environ = { 'HTTP_COOKIE': self.client.cookies, '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.client.errors, 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, } request = WSGIRequest(environ) request.session = self.client.session request.user = User() context['request'] = request self.context = context
def get_request(self, path=None): if not path: path = '/' environ = { 'HTTP_COOKIE': self.client.cookies, 'PATH_INFO': path, '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.client.errors, 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, } request = WSGIRequest(environ) request.session = self.client.session request.LANGUAGE_CODE = settings.LANGUAGE_CODE return request
def get_request(self, path=None, language=settings.LANGUAGES[0][0]): if not path: path = self.get_pages_root() parsed_path = urlparse(path) host = parsed_path.netloc or 'testserver' port = 80 if ':' in host: host, port = host.split(':', 1) environ = { 'HTTP_COOKIE': self.client.cookies, 'PATH_INFO': parsed_path.path, 'QUERY_STRING': parsed_path.query, 'REMOTE_ADDR': '127.0.0.1', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'SERVER_NAME': host, 'SERVER_PORT': port, 'SERVER_PROTOCOL': 'HTTP/1.1', 'wsgi.version': (1, 0), 'wsgi.url_scheme': 'http', 'wsgi.errors': self.client.errors, 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, } request = WSGIRequest(environ) request.session = self.client.session request.user = getattr(self, 'user', AnonymousUser()) request.LANGUAGE_CODE = language return request
def fake_request(path='/', method='GET', user=None, extra={}): params = { 'REQUEST_METHOD': method, 'PATH_INFO': path, 'wsgi.input': StringIO() } params.update(extra) req = WSGIRequest(params) req.user = user or AnonymousUser() req.user.id = '' req.user.username = '******' req.user.first_name = 'mock_user' req.user.is_superuser = True req.user.groups.all = lambda: [GroupFactory(id=1)] req.build_absolute_uri = lambda x=None: '/' # for sessions middleware req.session = build_fake_session() # for messages middleware req._messages = default_storage(req) req.get_host = lambda x=None: 'localhost' return req
def fake_request(path='/', method='GET', user=True, extra={}): params = { 'REQUEST_METHOD': method, 'PATH_INFO': path, 'wsgi.input': StringIO() } params.update(extra) req = WSGIRequest(params) if user: req.user = UserFactory.create(groups=(GroupFactory(), GroupFactory())) else: req.user = AnonymousUser() req.build_absolute_uri = lambda x=None: '/' # for sessions middleware req.session = build_fake_session() # for messages middleware req._messages = default_storage(req) req.get_host = lambda x=None: 'localhost' return req
def request(self, **request): request = WSGIRequest(self._base_environ(**request)) if self.session: request.session = self.session request.user = get_user(request) return request
def process_request(self, request: WSGIRequest): auth_token = request.META.get("HTTP_X_AUTH_TOKEN") if auth_token: session_key = auth_token request.session = self.SessionStore(session_key) else: super(AuthTokenAwareSessionMiddleware, self).process_request(request)
def wrapped_handler500(request): from oioioi.base.views import handler500 r = WSGIRequest(request) r.session = import_module(settings.SESSION_ENGINE).SessionStore() if self._user: r.user = self._user self._req = r return handler500(r)
def get_django_request(self): request = \ WSGIRequest(WSGIContainer.environ(self.request)) request.session = self.get_django_session() if self.current_user: request.user = self.current_user else: request.user = auth.models.AnonymousUser() return request
def get_request(path, method): """ @param path @param method @return: """ env = {"PATH_INFO": path, "REQUEST_METHOD": method} request = WSGIRequest(env) request.session = {} request.user = User() request.user.id = 1 return request
def get_request(self, path=None, language=None, post_data=None, enforce_csrf_checks=False): if not path: path = self.get_pages_root() if not language: language = settings.LANGUAGES[0][0] parsed_path = urlparse(path) host = parsed_path.netloc or "testserver" port = 80 if ":" in host: host, port = host.split(":", 1) environ = { "HTTP_COOKIE": self.client.cookies, "PATH_INFO": parsed_path.path, "QUERY_STRING": parsed_path.query, "REMOTE_ADDR": "127.0.0.1", "REQUEST_METHOD": "GET", "SCRIPT_NAME": "", "SERVER_NAME": host, "SERVER_PORT": port, "SERVER_PROTOCOL": "HTTP/1.1", "wsgi.version": (1, 0), "wsgi.url_scheme": "http", "wsgi.errors": self.client.errors, "wsgi.multiprocess": True, "wsgi.multithread": False, "wsgi.run_once": False, "wsgi.input": "", } if post_data: post_data = encode_multipart(BOUNDARY, post_data) environ.update( { "CONTENT_LENGTH": len(post_data), "CONTENT_TYPE": MULTIPART_CONTENT, "REQUEST_METHOD": "POST", "wsgi.input": FakePayload(post_data), } ) request = WSGIRequest(environ) request.session = self.client.session request.user = getattr(self, "user", AnonymousUser()) request.LANGUAGE_CODE = language if not enforce_csrf_checks: request.csrf_processing_done = True return request
def artificial_login(**credentials): from django.contrib.auth import authenticate, login cookies = SimpleCookie() user = authenticate(**credentials) engine = import_module(settings.SESSION_ENGINE) # Create a fake request that goes through request middleware request = WSGIRequest({ 'HTTP_COOKIE': cookies.output(header='', sep=';'), 'PATH_INFO': str('/'), 'REMOTE_ADDR': str('127.0.0.1'), 'REQUEST_METHOD': str('GET'), 'SCRIPT_NAME': str(''), 'SERVER_NAME': str('testserver'), 'SERVER_PORT': str('80'), 'SERVER_PROTOCOL': str('HTTP/1.1'), 'wsgi.version': (1, 0), 'wsgi.url_scheme': str('http'), 'wsgi.input': BytesIO(), 'wsgi.errors': BytesIO(), 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, }) request.session = engine.SessionStore() login(request, user) # Save the session values. request.session.save() # Set the cookie to represent the session. session_cookie = settings.SESSION_COOKIE_NAME cookies[session_cookie] = request.session.session_key cookie_data = { 'max-age': None, 'path': '/', 'domain': settings.SESSION_COOKIE_DOMAIN, 'secure': settings.SESSION_COOKIE_SECURE or None, 'expires': None, } cookies[session_cookie].update(cookie_data) return { session_cookie: cookies[session_cookie].value, settings.CSRF_COOKIE_NAME: csrf._get_new_csrf_key(), }
def artificial_login(**credentials): from django.contrib.auth import authenticate, login cookies = SimpleCookie() user = authenticate(**credentials) engine = import_module(settings.SESSION_ENGINE) # Create a fake request that goes through request middleware request = WSGIRequest({ "HTTP_COOKIE": cookies.output(header="", sep=";"), "PATH_INFO": "/", "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.input": BytesIO(), "wsgi.errors": BytesIO(), "wsgi.multiprocess": True, "wsgi.multithread": False, "wsgi.run_once": False, }) request.session = engine.SessionStore() login(request, user) # Save the session values. request.session.save() # Set the cookie to represent the session. session_cookie = settings.SESSION_COOKIE_NAME cookies[session_cookie] = request.session.session_key cookie_data = { "max-age": None, "path": "/", "domain": settings.SESSION_COOKIE_DOMAIN, "secure": settings.SESSION_COOKIE_SECURE or None, "expires": None, } cookies[session_cookie].update(cookie_data) return { session_cookie: cookies[session_cookie].value, settings.CSRF_COOKIE_NAME: csrf._get_new_csrf_key(), }
def artificial_login(**credentials): from django.contrib.auth import authenticate, login cookies = SimpleCookie() user = authenticate(**credentials) engine = import_module(settings.SESSION_ENGINE) # Create a fake request that goes through request middleware request = WSGIRequest( { "HTTP_COOKIE": cookies.output(header="", sep=";"), "PATH_INFO": str("/"), "REMOTE_ADDR": str("127.0.0.1"), "REQUEST_METHOD": str("GET"), "SCRIPT_NAME": str(""), "SERVER_NAME": str("testserver"), "SERVER_PORT": str("80"), "SERVER_PROTOCOL": str("HTTP/1.1"), "wsgi.version": (1, 0), "wsgi.url_scheme": str("http"), "wsgi.input": BytesIO(), "wsgi.errors": BytesIO(), "wsgi.multiprocess": True, "wsgi.multithread": False, "wsgi.run_once": False, } ) request.session = engine.SessionStore() login(request, user) # Save the session values. request.session.save() # Set the cookie to represent the session. session_cookie = settings.SESSION_COOKIE_NAME cookies[session_cookie] = request.session.session_key cookie_data = { "max-age": None, "path": "/", "domain": settings.SESSION_COOKIE_DOMAIN, "secure": settings.SESSION_COOKIE_SECURE or None, "expires": None, } cookies[session_cookie].update(cookie_data) return {session_cookie: cookies[session_cookie].value, settings.CSRF_COOKIE_NAME: csrf._get_new_csrf_key()}
def get_request(self, path=None, language=None, post_data=None): if not path: path = self.get_pages_root() if not language: language = settings.LANGUAGES[0][0] parsed_path = urlparse(path) host = parsed_path.netloc or 'testserver' port = 80 if ':' in host: host, port = host.split(':', 1) environ = { 'HTTP_COOKIE': self.client.cookies, 'PATH_INFO': parsed_path.path, 'QUERY_STRING': parsed_path.query, 'REMOTE_ADDR': '127.0.0.1', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'SERVER_NAME': host, 'SERVER_PORT': port, 'SERVER_PROTOCOL': 'HTTP/1.1', 'wsgi.version': (1,0), 'wsgi.url_scheme': 'http', 'wsgi.errors': self.client.errors, 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, 'wsgi.input': '' } if post_data: post_data = encode_multipart(BOUNDARY, post_data) environ.update({ 'CONTENT_LENGTH': len(post_data), 'CONTENT_TYPE': MULTIPART_CONTENT, 'REQUEST_METHOD': 'POST', 'wsgi.input': FakePayload(post_data), }) request = WSGIRequest(environ) request.session = self.client.session request.user = getattr(self, 'user', AnonymousUser()) request.LANGUAGE_CODE = language return request
def bogus_request(self, **request): """ The master request method. Composes the environment dictionary and passes to the handler, returning the result of the handler. Assumes defaults for the query environment, which can be overridden using the arguments to the request. """ 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", "HTTP_HOST": "localhost", "wsgi.version": (1, 0), "wsgi.url_scheme": "http", "wsgi.errors": None, # self.errors, "wsgi.multiprocess": True, "wsgi.multithread": False, "wsgi.run_once": False, "wsgi.input": None, } environ.update(self.defaults) environ.update(request) r = WSGIRequest(environ) if "django.contrib.sessions" in settings.INSTALLED_APPS: engine = __import__(settings.SESSION_ENGINE, {}, {}, [""]) r.session = engine.SessionStore() qlen = len(r.REQUEST.dicts) def setQuery(**query): r.REQUEST.dicts = r.REQUEST.dicts[:qlen] q = QueryDict("", mutable=True) q.update(query) r.REQUEST.dicts += (q,) r.setQuery = setQuery return r
def bogus_request(self, **request): """ The master request method. Composes the environment dictionary and passes to the handler, returning the result of the handler. Assumes defaults for the query environment, which can be overridden using the arguments to the request. """ 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', 'HTTP_HOST': 'localhost', 'wsgi.version': (1,0), 'wsgi.url_scheme': 'http', 'wsgi.errors': None,#self.errors, 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, 'wsgi.input': None, } environ.update(self.defaults) environ.update(request) r = WSGIRequest(environ) if 'django.contrib.sessions' in settings.INSTALLED_APPS: engine = __import__(settings.SESSION_ENGINE, {}, {}, ['']) r.session = engine.SessionStore() qlen = len(r.REQUEST.dicts) def setQuery (**query): r.REQUEST.dicts = r.REQUEST.dicts[:qlen] q = QueryDict('', mutable=True) q.update(query) r.REQUEST.dicts += (q,) r.setQuery = setQuery return r
def request_mock(base=settings.SITE_URL, path='/', query_string='', user=None): """ Create a request object that mocks a real one Useful in case a real request object is not available, but is needed (delayed Celery tasks for instance) """ url_parse = urlparse(base) request = WSGIRequest({ 'REQUEST_METHOD': 'GET', 'REQUEST_URI': path, 'PATH_INFO': path, 'QUERY_STRING': query_string, 'SCRIPT_NAME': '', 'HTTPS': ('on' if url_parse.scheme == 'https' else 'off'), 'HTTP_ACCEPT': '*/*', 'HTTP_HOST': url_parse.hostname, 'HTTP_REFERER': base, 'HTTP_USER_AGENT': 'MockRequest/1.0', 'HTTP_ACCEPT_LANGUAGE': 'en-US,en;q=0.8', 'SERVER_PROTOCOL': 'HTTP/1.1', 'SERVER_NAME': url_parse.hostname, 'SERVER_PORT': url_parse.port or (443 if url_parse.scheme == 'https' else 80), 'wsgi.input': StringIO(), 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, 'wsgi.url_scheme': url_parse.scheme or 'http', 'wsgi.version': (1, 0), }) request.user = AnonymousUser() if user is None else user request.session = {} return request
def get_request(self, path="/"): environ = { 'HTTP_COOKIE': self.client.cookies, 'PATH_INFO': path, '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.client.errors, 'wsgi.multiprocess': True, 'wsgi.multithread': False, 'wsgi.run_once': False, } request = WSGIRequest(environ) request.session = self.client.session request.user = self.user request.LANGUAGE_CODE = settings.LANGUAGES[0][0] return request
def request(self, **request): request = WSGIRequest(self._base_environ(**request)) request.user = AnonymousUser() request.session = MagicMock() return request
def request(self, **request): "Construct a generic request object." req = WSGIRequest(self._base_environ(**request)) req.session = {} return req