Debian Codegraph @

tests/messages_tests/test_fallback.py

raw
1 import random
2
3 from django.contrib.messages import constants
4 from django.contrib.messages.storage.fallback import CookieStorage, FallbackStorage
5 from django.test import SimpleTestCase
6 from django.utils.crypto import get_random_string
7
8 from .base import BaseTests
9 from .test_cookie import set_cookie_data, stored_cookie_messages_count
10 from .test_session import set_session_data, stored_session_messages_count
11
12
13 class FallbackTests(BaseTests, SimpleTestCase):
14 storage_class = FallbackStorage
15
16 def get_request(self):
17 self.session = {}
18 request = super().get_request()
19 request.session = self.session
20 return request
21
22 def get_cookie_storage(self, storage):
23 return storage.storages[-2]
24
25 def get_session_storage(self, storage):
26 return storage.storages[-1]
27
28 def stored_cookie_messages_count(self, storage, response):
29 return stored_cookie_messages_count(self.get_cookie_storage(storage), response)
30
31 def stored_session_messages_count(self, storage, response):
32 return stored_session_messages_count(self.get_session_storage(storage))
33
34 def stored_messages_count(self, storage, response):
35 """
36 Return the storage totals from both cookie and session backends.
37 """
38 return self.stored_cookie_messages_count(
39 storage, response
40 ) + self.stored_session_messages_count(storage, response)
41
42 def test_get(self):
43 request = self.get_request()
44 storage = self.storage_class(request)
45 cookie_storage = self.get_cookie_storage(storage)
46 # Set initial cookie data.
47 example_messages = [str(i) for i in range(5)]
48 set_cookie_data(cookie_storage, example_messages)
49 # Overwrite the _get method of the fallback storage to prove it is not
50 # used (it would cause a TypeError: 'NoneType' object is not callable).
51 self.get_session_storage(storage)._get = None
52 self.assertEqual(list(storage), example_messages)
53
54 def test_get_empty(self):
55 request = self.get_request()
56 storage = self.storage_class(request)
57 # Overwrite the _get method of the fallback storage to prove it is not
58 # used (it would cause a TypeError: 'NoneType' object is not callable).
59 self.get_session_storage(storage)._get = None
60 self.assertEqual(list(storage), [])
61
62 def test_get_fallback(self):
63 request = self.get_request()
64 storage = self.storage_class(request)
65 cookie_storage = self.get_cookie_storage(storage)
66 session_storage = self.get_session_storage(storage)
67
68 # Set initial cookie and session data.
69 example_messages = [str(i) for i in range(5)]
70 set_cookie_data(
71 cookie_storage, example_messages[:4] + [CookieStorage.not_finished]
72 )
73 set_session_data(session_storage, example_messages[4:])
74 self.assertEqual(list(storage), example_messages)
75
76 def test_get_fallback_only(self):
77 request = self.get_request()
78 storage = self.storage_class(request)
79 cookie_storage = self.get_cookie_storage(storage)
80 session_storage = self.get_session_storage(storage)
81 # Set initial cookie and session data.
82 example_messages = [str(i) for i in range(5)]
83 set_cookie_data(cookie_storage, [CookieStorage.not_finished], encode_empty=True)
84 set_session_data(session_storage, example_messages)
85 self.assertEqual(list(storage), example_messages)
86
87 def test_flush_used_backends(self):
88 request = self.get_request()
89 storage = self.storage_class(request)
90 cookie_storage = self.get_cookie_storage(storage)
91 session_storage = self.get_session_storage(storage)
92 # Set initial cookie and session data.
93 set_cookie_data(cookie_storage, ["cookie", CookieStorage.not_finished])
94 set_session_data(session_storage, ["session"])
95 # When updating, previously used but no longer needed backends are
96 # flushed.
97 response = self.get_response()
98 list(storage)
99 storage.update(response)
100 session_storing = self.stored_session_messages_count(storage, response)
101 self.assertEqual(session_storing, 0)
102
103 def test_no_fallback(self):
104 """
105 (1) A short number of messages whose data size doesn't exceed what is
106 allowed in a cookie will all be stored in the CookieBackend.
107
108 (2) If the CookieBackend can store all messages, the SessionBackend
109 won't be written to at all.
110 """
111 storage = self.get_storage()
112 response = self.get_response()
113 # Overwrite the _store method of the fallback storage to prove it isn't
114 # used (it would cause a TypeError: 'NoneType' object is not callable).
115 self.get_session_storage(storage)._store = None
116 for i in range(5):
117 storage.add(constants.INFO, str(i) * 100)
118 storage.update(response)
119 cookie_storing = self.stored_cookie_messages_count(storage, response)
120 self.assertEqual(cookie_storing, 5)
121 session_storing = self.stored_session_messages_count(storage, response)
122 self.assertEqual(session_storing, 0)
123
124 def test_session_fallback(self):
125 """
126 If the data exceeds what is allowed in a cookie, messages which did
127 not fit are stored in the SessionBackend.
128 """
129 storage = self.get_storage()
130 response = self.get_response()
131 # see comment in CookieTests.test_cookie_max_length()
132 msg_size = int((CookieStorage.max_cookie_size - 54) / 4.5 - 37)
133 # Generate the same (tested) content every time that does not get run
134 # through zlib compression.
135 random.seed(42)
136 for i in range(5):
137 storage.add(constants.INFO, get_random_string(msg_size))
138 storage.update(response)
139 cookie_storing = self.stored_cookie_messages_count(storage, response)
140 self.assertEqual(cookie_storing, 4)
141 session_storing = self.stored_session_messages_count(storage, response)
142 self.assertEqual(session_storing, 1)
143
144 def test_session_fallback_only(self):
145 """
146 Large messages, none of which fit in a cookie, are stored in the
147 SessionBackend (and nothing is stored in the CookieBackend).
148 """
149 storage = self.get_storage()
150 response = self.get_response()
151 # Generate the same (tested) content every time that does not get run
152 # through zlib compression.
153 random.seed(42)
154 storage.add(constants.INFO, get_random_string(5000))
155 storage.update(response)
156 cookie_storing = self.stored_cookie_messages_count(storage, response)
157 self.assertEqual(cookie_storing, 0)
158 session_storing = self.stored_session_messages_count(storage, response)
159 self.assertEqual(session_storing, 1)