Debian Codegraph @

tests/deprecation/test_middleware_mixin.py

raw
1 import threading
2
3 from asgiref.sync import async_to_sync, iscoroutinefunction
4
5 from django.contrib.admindocs.middleware import XViewMiddleware
6 from django.contrib.auth.middleware import (
7 AuthenticationMiddleware,
8 LoginRequiredMiddleware,
9 )
10 from django.contrib.flatpages.middleware import FlatpageFallbackMiddleware
11 from django.contrib.messages.middleware import MessageMiddleware
12 from django.contrib.redirects.middleware import RedirectFallbackMiddleware
13 from django.contrib.sessions.middleware import SessionMiddleware
14 from django.contrib.sites.middleware import CurrentSiteMiddleware
15 from django.db import connection
16 from django.http.request import HttpRequest
17 from django.http.response import HttpResponse
18 from django.middleware.cache import (
19 CacheMiddleware,
20 FetchFromCacheMiddleware,
21 UpdateCacheMiddleware,
22 )
23 from django.middleware.clickjacking import XFrameOptionsMiddleware
24 from django.middleware.common import BrokenLinkEmailsMiddleware, CommonMiddleware
25 from django.middleware.csrf import CsrfViewMiddleware
26 from django.middleware.gzip import GZipMiddleware
27 from django.middleware.http import ConditionalGetMiddleware
28 from django.middleware.locale import LocaleMiddleware
29 from django.middleware.security import SecurityMiddleware
30 from django.test import SimpleTestCase
31 from django.utils.deprecation import MiddlewareMixin
32
33
34 class MiddlewareMixinTests(SimpleTestCase):
35 middlewares = [
36 AuthenticationMiddleware,
37 LoginRequiredMiddleware,
38 BrokenLinkEmailsMiddleware,
39 CacheMiddleware,
40 CommonMiddleware,
41 ConditionalGetMiddleware,
42 CsrfViewMiddleware,
43 CurrentSiteMiddleware,
44 FetchFromCacheMiddleware,
45 FlatpageFallbackMiddleware,
46 GZipMiddleware,
47 LocaleMiddleware,
48 MessageMiddleware,
49 RedirectFallbackMiddleware,
50 SecurityMiddleware,
51 SessionMiddleware,
52 UpdateCacheMiddleware,
53 XFrameOptionsMiddleware,
54 XViewMiddleware,
55 ]
56
57 def test_repr(self):
58 class GetResponse:
59 def __call__(self):
60 return HttpResponse()
61
62 def get_response():
63 return HttpResponse()
64
65 self.assertEqual(
66 repr(MiddlewareMixin(GetResponse())),
67 "<MiddlewareMixin get_response=GetResponse>",
68 )
69 self.assertEqual(
70 repr(MiddlewareMixin(get_response)),
71 "<MiddlewareMixin get_response="
72 "MiddlewareMixinTests.test_repr.<locals>.get_response>",
73 )
74 self.assertEqual(
75 repr(CsrfViewMiddleware(GetResponse())),
76 "<CsrfViewMiddleware get_response=GetResponse>",
77 )
78 self.assertEqual(
79 repr(CsrfViewMiddleware(get_response)),
80 "<CsrfViewMiddleware get_response="
81 "MiddlewareMixinTests.test_repr.<locals>.get_response>",
82 )
83
84 def test_passing_explicit_none(self):
85 msg = "get_response must be provided."
86 for middleware in self.middlewares:
87 with self.subTest(middleware=middleware):
88 with self.assertRaisesMessage(ValueError, msg):
89 middleware(None)
90
91 def test_coroutine(self):
92 async def async_get_response(request):
93 return HttpResponse()
94
95 def sync_get_response(request):
96 return HttpResponse()
97
98 for middleware in self.middlewares:
99 with self.subTest(middleware=middleware.__qualname__):
100 # Middleware appears as coroutine if get_function is
101 # a coroutine.
102 middleware_instance = middleware(async_get_response)
103 self.assertIs(iscoroutinefunction(middleware_instance), True)
104 # Middleware doesn't appear as coroutine if get_function is not
105 # a coroutine.
106 middleware_instance = middleware(sync_get_response)
107 self.assertIs(iscoroutinefunction(middleware_instance), False)
108
109 def test_sync_to_async_uses_base_thread_and_connection(self):
110 """
111 The process_request() and process_response() hooks must be called with
112 the sync_to_async thread_sensitive flag enabled, so that database
113 operations use the correct thread and connection.
114 """
115
116 def request_lifecycle():
117 """Fake request_started/request_finished."""
118 return (threading.get_ident(), id(connection))
119
120 async def get_response(self):
121 return HttpResponse()
122
123 class SimpleMiddleWare(MiddlewareMixin):
124 def process_request(self, request):
125 request.thread_and_connection = request_lifecycle()
126
127 def process_response(self, request, response):
128 response.thread_and_connection = request_lifecycle()
129 return response
130
131 threads_and_connections = []
132 threads_and_connections.append(request_lifecycle())
133
134 request = HttpRequest()
135 response = async_to_sync(SimpleMiddleWare(get_response))(request)
136 threads_and_connections.append(request.thread_and_connection)
137 threads_and_connections.append(response.thread_and_connection)
138
139 threads_and_connections.append(request_lifecycle())
140
141 self.assertEqual(len(threads_and_connections), 4)
142 self.assertEqual(len(set(threads_and_connections)), 1)