def get_anonymous_request(leonardo_page):
"""returns inicialized request
"""
request_factory = RequestFactory()
request = request_factory.get(leonardo_page.get_absolute_url(), data={})
request.feincms_page = request.leonardo_page = leonardo_page
request.frontend_editing = False
request.user = AnonymousUser()
if not hasattr(request, '_feincms_extra_context'):
request._feincms_extra_context = {}
request.path = leonardo_page.get_absolute_url()
request.frontend_editing = False
leonardo_page.run_request_processors(request)
request.LEONARDO_CONFIG = ContextConfig(request)
handler = BaseHandler()
handler.load_middleware()
# Apply request middleware
for middleware_method in handler._request_middleware:
try:
middleware_method(request)
except:
pass
# call processors
for fn in reversed(list(leonardo_page.request_processors.values())):
fn(leonardo_page, request)
return request
def setUp(self):
factory = RequestFactory()
self.request = factory.post('/api/')
# Adding middleware and session to the request object.
# Source: https://gist.github.com/tschellenbach/925270
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(self.request):
raise Exception(
'Could not create request object; request middleware returned a response'
)
self.password = '******'
self.admin = User.objects.create_superuser('admin', 'admin@local',
self.password)
self.account = User.objects.create_user('test', 'test@local',
self.password)
self.building = Building.objects.create(title='test',
creator=self.admin,
modifier=self.admin)
self.other_building = Building.objects.create(title='test2',
creator=self.admin,
modifier=self.admin)
self.location = Location.objects.create(building=self.building,
user=self.account)
self.location_with_apartment = Location.objects.create(
building=self.building, apartment=1, user=self.account)
self.update_account()
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 object - "
"request middleware returned a response")
return request
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 _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 __init__(self, *args, **kwargs):
self.handler = BaseHandler()
self.handler.load_middleware()
self.site = self.get_site()
super(WagtailBakeryView, self).__init__(*args, **kwargs)
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 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):
"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
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 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 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 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 __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 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 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
def test_plugins_middleware_loads_requestor_in_plugin(rf, customer_user,
settings):
settings.MIDDLEWARE = [
"saleor.core.middleware.plugins",
]
settings.PLUGINS = ["saleor.plugins.tests.sample_plugins.ActivePlugin"]
request = rf.request()
request.user = customer_user
request.app = None
handler = BaseHandler()
handler.load_middleware()
handler.get_response(request)
plugin = request.plugins.all_plugins.pop()
assert isinstance(plugin.requestor, type(customer_user))
assert plugin.requestor.id == customer_user.id
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 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
if hasattr(handler, '_request_middleware'):
for middleware_method in handler._request_middleware:
middleware_method(request)
else:
handler.get_response(request)
return request
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 _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 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 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_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 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
