Debian Codegraph @

tests/async/tests.py

raw
1 import asyncio
2 import os
3 from unittest import mock
4
5 from asgiref.sync import async_to_sync, iscoroutinefunction
6
7 from django.core.cache import DEFAULT_CACHE_ALIAS, caches
8 from django.core.exceptions import ImproperlyConfigured, SynchronousOnlyOperation
9 from django.http import HttpResponse, HttpResponseNotAllowed
10 from django.test import RequestFactory, SimpleTestCase
11 from django.utils.asyncio import async_unsafe
12 from django.views.generic.base import View
13
14 from .models import SimpleModel
15
16
17 class CacheTest(SimpleTestCase):
18 def test_caches_local(self):
19 @async_to_sync
20 async def async_cache():
21 return caches[DEFAULT_CACHE_ALIAS]
22
23 cache_1 = async_cache()
24 cache_2 = async_cache()
25 self.assertIs(cache_1, cache_2)
26
27
28 class DatabaseConnectionTest(SimpleTestCase):
29 """A database connection cannot be used in an async context."""
30
31 async def test_get_async_connection(self):
32 with self.assertRaises(SynchronousOnlyOperation):
33 list(SimpleModel.objects.all())
34
35
36 class AsyncUnsafeTest(SimpleTestCase):
37 """
38 async_unsafe decorator should work correctly and returns the correct
39 message.
40 """
41
42 @async_unsafe
43 def dangerous_method(self):
44 return True
45
46 async def test_async_unsafe(self):
47 # async_unsafe decorator catches bad access and returns the right
48 # message.
49 msg = (
50 "You cannot call this from an async context - use a thread or "
51 "sync_to_async."
52 )
53 with self.assertRaisesMessage(SynchronousOnlyOperation, msg):
54 self.dangerous_method()
55
56 @mock.patch.dict(os.environ, {"DJANGO_ALLOW_ASYNC_UNSAFE": "true"})
57 @async_to_sync # mock.patch() is not async-aware.
58 async def test_async_unsafe_suppressed(self):
59 # Decorator doesn't trigger check when the environment variable to
60 # suppress it is set.
61 try:
62 self.dangerous_method()
63 except SynchronousOnlyOperation:
64 self.fail("SynchronousOnlyOperation should not be raised.")
65
66
67 class SyncView(View):
68 def get(self, request, *args, **kwargs):
69 return HttpResponse("Hello (sync) world!")
70
71
72 class AsyncView(View):
73 async def get(self, request, *args, **kwargs):
74 return HttpResponse("Hello (async) world!")
75
76
77 class ViewTests(SimpleTestCase):
78 def test_views_are_correctly_marked(self):
79 tests = [
80 (SyncView, False),
81 (AsyncView, True),
82 ]
83 for view_cls, is_async in tests:
84 with self.subTest(view_cls=view_cls, is_async=is_async):
85 self.assertIs(view_cls.view_is_async, is_async)
86 callback = view_cls.as_view()
87 self.assertIs(iscoroutinefunction(callback), is_async)
88
89 def test_mixed_views_raise_error(self):
90 class MixedView(View):
91 def get(self, request, *args, **kwargs):
92 return HttpResponse("Hello (mixed) world!")
93
94 async def post(self, request, *args, **kwargs):
95 return HttpResponse("Hello (mixed) world!")
96
97 msg = (
98 f"{MixedView.__qualname__} HTTP handlers must either be all sync or all "
99 "async."
100 )
101 with self.assertRaisesMessage(ImproperlyConfigured, msg):
102 MixedView.as_view()
103
104 def test_options_handler_responds_correctly(self):
105 tests = [
106 (SyncView, False),
107 (AsyncView, True),
108 ]
109 for view_cls, is_coroutine in tests:
110 with self.subTest(view_cls=view_cls, is_coroutine=is_coroutine):
111 instance = view_cls()
112 response = instance.options(None)
113 self.assertIs(
114 asyncio.iscoroutine(response),
115 is_coroutine,
116 )
117 if is_coroutine:
118 response = asyncio.run(response)
119
120 self.assertIsInstance(response, HttpResponse)
121
122 def test_http_method_not_allowed_responds_correctly(self):
123 request_factory = RequestFactory()
124 tests = [
125 (SyncView, False),
126 (AsyncView, True),
127 ]
128 for view_cls, is_coroutine in tests:
129 with self.subTest(view_cls=view_cls, is_coroutine=is_coroutine):
130 instance = view_cls()
131 response = instance.http_method_not_allowed(request_factory.post("/"))
132 self.assertIs(
133 asyncio.iscoroutine(response),
134 is_coroutine,
135 )
136 if is_coroutine:
137 response = asyncio.run(response)
138
139 self.assertIsInstance(response, HttpResponseNotAllowed)
140
141 def test_base_view_class_is_sync(self):
142 """
143 View and by extension any subclasses that don't define handlers are
144 sync.
145 """
146 self.assertIs(View.view_is_async, False)