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 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 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 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_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
def request(self, **request):
"Construct a generic request object."
req = WSGIRequest(self._base_environ(**request))
req.session = {}
return req
