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)