--- /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)