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