diff -r b758351d191f -r cc9b7e14412b web/lib/django/contrib/messages/tests/fallback.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django/contrib/messages/tests/fallback.py Tue May 25 02:43:45 2010 +0200 @@ -0,0 +1,175 @@ +from django.contrib.messages import constants +from django.contrib.messages.storage.fallback import FallbackStorage, \ + CookieStorage +from django.contrib.messages.tests.base import BaseTest +from django.contrib.messages.tests.cookie import set_cookie_data, \ + stored_cookie_messages_count +from django.contrib.messages.tests.session import set_session_data, \ + stored_session_messages_count + + +class FallbackTest(BaseTest): + storage_class = FallbackStorage + + def get_request(self): + self.session = {} + request = super(FallbackTest, self).get_request() + request.session = self.session + return request + + def get_cookie_storage(self, storage): + return storage.storages[-2] + + def get_session_storage(self, storage): + return storage.storages[-1] + + def stored_cookie_messages_count(self, storage, response): + return stored_cookie_messages_count(self.get_cookie_storage(storage), + response) + + def stored_session_messages_count(self, storage, response): + return stored_session_messages_count(self.get_session_storage(storage)) + + def stored_messages_count(self, storage, response): + """ + Return the storage totals from both cookie and session backends. + """ + total = (self.stored_cookie_messages_count(storage, response) + + self.stored_session_messages_count(storage, response)) + return total + + def test_get(self): + request = self.get_request() + storage = self.storage_class(request) + cookie_storage = self.get_cookie_storage(storage) + + # Set initial cookie data. + example_messages = [str(i) for i in range(5)] + set_cookie_data(cookie_storage, example_messages) + + # Overwrite the _get method of the fallback storage to prove it is not + # used (it would cause a TypeError: 'NoneType' object is not callable). + self.get_session_storage(storage)._get = None + + # Test that the message actually contains what we expect. + self.assertEqual(list(storage), example_messages) + + def test_get_empty(self): + request = self.get_request() + storage = self.storage_class(request) + + # Overwrite the _get method of the fallback storage to prove it is not + # used (it would cause a TypeError: 'NoneType' object is not callable). + self.get_session_storage(storage)._get = None + + # Test that the message actually contains what we expect. + self.assertEqual(list(storage), []) + + def test_get_fallback(self): + request = self.get_request() + storage = self.storage_class(request) + cookie_storage = self.get_cookie_storage(storage) + session_storage = self.get_session_storage(storage) + + # Set initial cookie and session data. + example_messages = [str(i) for i in range(5)] + set_cookie_data(cookie_storage, example_messages[:4] + + [CookieStorage.not_finished]) + set_session_data(session_storage, example_messages[4:]) + + # Test that the message actually contains what we expect. + self.assertEqual(list(storage), example_messages) + + def test_get_fallback_only(self): + request = self.get_request() + storage = self.storage_class(request) + cookie_storage = self.get_cookie_storage(storage) + session_storage = self.get_session_storage(storage) + + # Set initial cookie and session data. + example_messages = [str(i) for i in range(5)] + set_cookie_data(cookie_storage, [CookieStorage.not_finished], + encode_empty=True) + set_session_data(session_storage, example_messages) + + # Test that the message actually contains what we expect. + self.assertEqual(list(storage), example_messages) + + def test_flush_used_backends(self): + request = self.get_request() + storage = self.storage_class(request) + cookie_storage = self.get_cookie_storage(storage) + session_storage = self.get_session_storage(storage) + + # Set initial cookie and session data. + set_cookie_data(cookie_storage, ['cookie', CookieStorage.not_finished]) + set_session_data(session_storage, ['session']) + + # When updating, previously used but no longer needed backends are + # flushed. + response = self.get_response() + list(storage) + storage.update(response) + session_storing = self.stored_session_messages_count(storage, response) + self.assertEqual(session_storing, 0) + + def test_no_fallback(self): + """ + Confirms that: + + (1) A short number of messages whose data size doesn't exceed what is + allowed in a cookie will all be stored in the CookieBackend. + + (2) If the CookieBackend can store all messages, the SessionBackend + won't be written to at all. + """ + storage = self.get_storage() + response = self.get_response() + + # Overwrite the _store method of the fallback storage to prove it isn't + # used (it would cause a TypeError: 'NoneType' object is not callable). + self.get_session_storage(storage)._store = None + + for i in range(5): + storage.add(constants.INFO, str(i) * 100) + storage.update(response) + + cookie_storing = self.stored_cookie_messages_count(storage, response) + self.assertEqual(cookie_storing, 5) + session_storing = self.stored_session_messages_count(storage, response) + self.assertEqual(session_storing, 0) + + def test_session_fallback(self): + """ + Confirms that, if the data exceeds what is allowed in a cookie, + messages which did not fit are stored in the SessionBackend. + """ + storage = self.get_storage() + response = self.get_response() + + # see comment in CookieText.test_cookie_max_length + msg_size = int((CookieStorage.max_cookie_size - 54) / 4.5 - 37) + for i in range(5): + storage.add(constants.INFO, str(i) * msg_size) + storage.update(response) + + cookie_storing = self.stored_cookie_messages_count(storage, response) + self.assertEqual(cookie_storing, 4) + session_storing = self.stored_session_messages_count(storage, response) + self.assertEqual(session_storing, 1) + + def test_session_fallback_only(self): + """ + Confirms that large messages, none of which fit in a cookie, are stored + in the SessionBackend (and nothing is stored in the CookieBackend). + """ + storage = self.get_storage() + response = self.get_response() + + storage.add(constants.INFO, 'x' * 5000) + storage.update(response) + + cookie_storing = self.stored_cookie_messages_count(storage, response) + self.assertEqual(cookie_storing, 0) + session_storing = self.stored_session_messages_count(storage, response) + self.assertEqual(session_storing, 1)