/tests/regressiontests/decorators/tests.py
Python | 274 lines | 172 code | 50 blank | 52 comment | 1 complexity | 5af0f717fed9be79b2cb20bd02aaa02f MD5 | raw file
- from functools import wraps
- import warnings
- from django.contrib.auth.decorators import login_required, permission_required, user_passes_test
- from django.contrib.admin.views.decorators import staff_member_required
- from django.http import HttpResponse, HttpRequest, HttpResponseNotAllowed
- from django.test.utils import get_warnings_state, restore_warnings_state
- from django.utils.decorators import method_decorator
- from django.utils.functional import allow_lazy, lazy, memoize
- from django.utils.unittest import TestCase
- from django.views.decorators.http import require_http_methods, require_GET, require_POST, require_safe
- from django.views.decorators.vary import vary_on_headers, vary_on_cookie
- from django.views.decorators.cache import cache_page, never_cache, cache_control
- from django.views.decorators.clickjacking import xframe_options_deny, xframe_options_sameorigin, xframe_options_exempt
- from django.middleware.clickjacking import XFrameOptionsMiddleware
- def fully_decorated(request):
- """Expected __doc__"""
- return HttpResponse('<html><body>dummy</body></html>')
- fully_decorated.anything = "Expected __dict__"
- def compose(*functions):
- # compose(f, g)(*args, **kwargs) == f(g(*args, **kwargs))
- functions = list(reversed(functions))
- def _inner(*args, **kwargs):
- result = functions[0](*args, **kwargs)
- for f in functions[1:]:
- result = f(result)
- return result
- return _inner
- full_decorator = compose(
- # django.views.decorators.http
- require_http_methods(["GET"]),
- require_GET,
- require_POST,
- require_safe,
- # django.views.decorators.vary
- vary_on_headers('Accept-language'),
- vary_on_cookie,
- # django.views.decorators.cache
- cache_page(60*15),
- cache_control(private=True),
- never_cache,
- # django.contrib.auth.decorators
- # Apply user_passes_test twice to check #9474
- user_passes_test(lambda u:True),
- login_required,
- permission_required('change_world'),
- # django.contrib.admin.views.decorators
- staff_member_required,
- # django.utils.functional
- lambda f: memoize(f, {}, 1),
- allow_lazy,
- lazy,
- )
- fully_decorated = full_decorator(fully_decorated)
- class DecoratorsTest(TestCase):
- def setUp(self):
- self.warning_state = get_warnings_state()
- warnings.filterwarnings('ignore', category=PendingDeprecationWarning,
- module='django.views.decorators.cache')
- def tearDown(self):
- restore_warnings_state(self.warning_state)
- def test_attributes(self):
- """
- Tests that django decorators set certain attributes of the wrapped
- function.
- """
- self.assertEqual(fully_decorated.__name__, 'fully_decorated')
- self.assertEqual(fully_decorated.__doc__, 'Expected __doc__')
- self.assertEqual(fully_decorated.__dict__['anything'], 'Expected __dict__')
- def test_user_passes_test_composition(self):
- """
- Test that the user_passes_test decorator can be applied multiple times
- (#9474).
- """
- def test1(user):
- user.decorators_applied.append('test1')
- return True
- def test2(user):
- user.decorators_applied.append('test2')
- return True
- def callback(request):
- return request.user.decorators_applied
- callback = user_passes_test(test1)(callback)
- callback = user_passes_test(test2)(callback)
- class DummyUser(object): pass
- class DummyRequest(object): pass
- request = DummyRequest()
- request.user = DummyUser()
- request.user.decorators_applied = []
- response = callback(request)
- self.assertEqual(response, ['test2', 'test1'])
- def test_cache_page_new_style(self):
- """
- Test that we can call cache_page the new way
- """
- def my_view(request):
- return "response"
- my_view_cached = cache_page(123)(my_view)
- self.assertEqual(my_view_cached(HttpRequest()), "response")
- my_view_cached2 = cache_page(123, key_prefix="test")(my_view)
- self.assertEqual(my_view_cached2(HttpRequest()), "response")
- def test_cache_page_old_style(self):
- """
- Test that we can call cache_page the old way
- """
- def my_view(request):
- return "response"
- my_view_cached = cache_page(my_view, 123)
- self.assertEqual(my_view_cached(HttpRequest()), "response")
- my_view_cached2 = cache_page(my_view, 123, key_prefix="test")
- self.assertEqual(my_view_cached2(HttpRequest()), "response")
- my_view_cached3 = cache_page(my_view)
- self.assertEqual(my_view_cached3(HttpRequest()), "response")
- my_view_cached4 = cache_page()(my_view)
- self.assertEqual(my_view_cached4(HttpRequest()), "response")
- def test_require_safe_accepts_only_safe_methods(self):
- """
- Test for the require_safe decorator.
- A view returns either a response or an exception.
- Refs #15637.
- """
- def my_view(request):
- return HttpResponse("OK")
- my_safe_view = require_safe(my_view)
- request = HttpRequest()
- request.method = 'GET'
- self.assertTrue(isinstance(my_safe_view(request), HttpResponse))
- request.method = 'HEAD'
- self.assertTrue(isinstance(my_safe_view(request), HttpResponse))
- request.method = 'POST'
- self.assertTrue(isinstance(my_safe_view(request), HttpResponseNotAllowed))
- request.method = 'PUT'
- self.assertTrue(isinstance(my_safe_view(request), HttpResponseNotAllowed))
- request.method = 'DELETE'
- self.assertTrue(isinstance(my_safe_view(request), HttpResponseNotAllowed))
- # For testing method_decorator, a decorator that assumes a single argument.
- # We will get type arguments if there is a mismatch in the number of arguments.
- def simple_dec(func):
- def wrapper(arg):
- return func("test:" + arg)
- return wraps(func)(wrapper)
- simple_dec_m = method_decorator(simple_dec)
- # For testing method_decorator, two decorators that add an attribute to the function
- def myattr_dec(func):
- def wrapper(*args, **kwargs):
- return func(*args, **kwargs)
- wrapper.myattr = True
- return wraps(func)(wrapper)
- myattr_dec_m = method_decorator(myattr_dec)
- def myattr2_dec(func):
- def wrapper(*args, **kwargs):
- return func(*args, **kwargs)
- wrapper.myattr2 = True
- return wraps(func)(wrapper)
- myattr2_dec_m = method_decorator(myattr2_dec)
- class MethodDecoratorTests(TestCase):
- """
- Tests for method_decorator
- """
- def test_preserve_signature(self):
- class Test(object):
- @simple_dec_m
- def say(self, arg):
- return arg
- self.assertEqual("test:hello", Test().say("hello"))
- def test_preserve_attributes(self):
- # Sanity check myattr_dec and myattr2_dec
- @myattr_dec
- @myattr2_dec
- def func():
- pass
- self.assertEqual(getattr(func, 'myattr', False), True)
- self.assertEqual(getattr(func, 'myattr2', False), True)
- # Now check method_decorator
- class Test(object):
- @myattr_dec_m
- @myattr2_dec_m
- def method(self):
- "A method"
- pass
- self.assertEqual(getattr(Test().method, 'myattr', False), True)
- self.assertEqual(getattr(Test().method, 'myattr2', False), True)
- self.assertEqual(getattr(Test.method, 'myattr', False), True)
- self.assertEqual(getattr(Test.method, 'myattr2', False), True)
- self.assertEqual(Test.method.__doc__, 'A method')
- self.assertEqual(Test.method.im_func.__name__, 'method')
- class XFrameOptionsDecoratorsTests(TestCase):
- """
- Tests for the X-Frame-Options decorators.
- """
- def test_deny_decorator(self):
- """
- Ensures @xframe_options_deny properly sets the X-Frame-Options header.
- """
- @xframe_options_deny
- def a_view(request):
- return HttpResponse()
- r = a_view(HttpRequest())
- self.assertEqual(r['X-Frame-Options'], 'DENY')
- def test_sameorigin_decorator(self):
- """
- Ensures @xframe_options_sameorigin properly sets the X-Frame-Options
- header.
- """
- @xframe_options_sameorigin
- def a_view(request):
- return HttpResponse()
- r = a_view(HttpRequest())
- self.assertEqual(r['X-Frame-Options'], 'SAMEORIGIN')
- def test_exempt_decorator(self):
- """
- Ensures @xframe_options_exempt properly instructs the
- XFrameOptionsMiddleware to NOT set the header.
- """
- @xframe_options_exempt
- def a_view(request):
- return HttpResponse()
- req = HttpRequest()
- resp = a_view(req)
- self.assertEqual(resp.get('X-Frame-Options', None), None)
- self.assertTrue(resp.xframe_options_exempt)
- # Since the real purpose of the exempt decorator is to suppress
- # the middleware's functionality, let's make sure it actually works...
- r = XFrameOptionsMiddleware().process_response(req, resp)
- self.assertEqual(r.get('X-Frame-Options', None), None)