Converted sessions tests from doctest to unittest.

            finally:

                session_file.close()

        except IOError:

            pass

            self.create()

        return session_data

    def create(self):

r"""

>>> from django.conf import settings

>>> from django.contrib.sessions.backends.db import SessionStore as DatabaseSession

>>> from django.contrib.sessions.backends.cache import SessionStore as CacheSession

>>> from django.contrib.sessions.backends.cached_db import SessionStore as CacheDBSession

>>> from django.contrib.sessions.backends.file import SessionStore as FileSession

>>> from django.contrib.sessions.backends.base import SessionBase

>>> from django.contrib.sessions.models import Session

>>> db_session = DatabaseSession()

>>> db_session.modified

False

>>> db_session.get('cat')

>>> db_session['cat'] = "dog"

>>> db_session.modified

True

>>> db_session.pop('cat')

'dog'

>>> db_session.pop('some key', 'does not exist')

'does not exist'

>>> db_session.save()

>>> db_session.exists(db_session.session_key)

True

>>> db_session.delete(db_session.session_key)

>>> db_session.exists(db_session.session_key)

False

>>> db_session['foo'] = 'bar'

>>> db_session.save()

>>> db_session.exists(db_session.session_key)

True

>>> prev_key = db_session.session_key

>>> db_session.flush()

>>> db_session.exists(prev_key)

False

>>> db_session.session_key == prev_key

False

>>> db_session.modified, db_session.accessed

(True, True)

>>> db_session['a'], db_session['b'] = 'c', 'd'

>>> db_session.save()

>>> prev_key = db_session.session_key

>>> prev_data = db_session.items()

>>> db_session.cycle_key()

>>> db_session.session_key == prev_key

False

>>> db_session.items() == prev_data

True

from datetime import datetime, timedelta

from django.conf import settings

from django.contrib.sessions.backends.db import SessionStore as DatabaseSession

from django.contrib.sessions.backends.cache import SessionStore as CacheSession

from django.contrib.sessions.backends.cached_db import SessionStore as CacheDBSession

from django.contrib.sessions.backends.file import SessionStore as FileSession

from django.contrib.sessions.backends.base import SessionBase

from django.contrib.sessions.models import Session

from django.core.exceptions import ImproperlyConfigured

from django.test import TestCase

import shutil

import tempfile

import unittest

class SessionTestsMixin(object):

    # This does not inherit from TestCase to avoid any tests being run with this

    # class, which wouldn't work, and to allow different TestCase subclasses to

    # be used.

    backend = None # subclasses must specify

    def setUp(self):

        self.session = self.backend()

    def tearDown(self):

        # NB: be careful to delete any sessions created; stale sessions fill up

        # the /tmp (with some backends) and eventually overwhelm it after lots

        # of runs (think buildbots)

        self.session.delete()

    def test_new_session(self):

        self.assertFalse(self.session.modified)

        self.assertFalse(self.session.accessed)

    def test_get_empty(self):

        self.assertEqual(self.session.get('cat'), None)

    def test_store(self):

        self.session['cat'] = "dog"

        self.assertTrue(self.session.modified)

        self.assertEqual(self.session.pop('cat'), 'dog')

    def test_pop(self):

        self.session['some key'] = 'exists'

        # Need to reset these to pretend we haven't accessed it:

        self.accessed = False

        self.modified = False

        self.assertEqual(self.session.pop('some key'), 'exists')

        self.assertTrue(self.session.accessed)

        self.assertTrue(self.session.modified)

        self.assertEqual(self.session.get('some key'), None)

    def test_pop_default(self):

        self.assertEqual(self.session.pop('some key', 'does not exist'),

                         'does not exist')

        self.assertTrue(self.session.accessed)

        self.assertFalse(self.session.modified)

    def test_setdefault(self):

        self.assertEqual(self.session.setdefault('foo', 'bar'), 'bar')

        self.assertEqual(self.session.setdefault('foo', 'baz'), 'bar')

        self.assertTrue(self.session.accessed)

        self.assertTrue(self.session.modified)

    def test_update(self):

        self.session.update({'update key': 1})

        self.assertTrue(self.session.accessed)

        self.assertTrue(self.session.modified)

        self.assertEqual(self.session.get('update key', None), 1)

    def test_has_key(self):

        self.session['some key'] = 1

        self.session.modified = False

        self.session.accessed = False

        self.assertTrue(self.session.has_key('some key'))

        self.assertTrue(self.session.accessed)

        self.assertFalse(self.session.modified)

    def test_values(self):

        self.assertEqual(self.session.values(), [])

        self.assertTrue(self.session.accessed)

        self.session['some key'] = 1

        self.assertEqual(self.session.values(), [1])

    def test_iterkeys(self):

        self.session['x'] = 1

        self.session.modified = False

        self.session.accessed = False

        i = self.session.iterkeys()

        self.assertTrue(hasattr(i, '__iter__'))

        self.assertTrue(self.session.accessed)

        self.assertFalse(self.session.modified)

        self.assertEqual(list(i), ['x'])

    def test_iterkeys(self):

        self.session['x'] = 1

        self.session.modified = False

        self.session.accessed = False

        i = self.session.itervalues()

        self.assertTrue(hasattr(i, '__iter__'))

        self.assertTrue(self.session.accessed)

        self.assertFalse(self.session.modified)

        self.assertEqual(list(i), [1])

    def test_iteritems(self):

        self.session['x'] = 1

        self.session.modified = False

        self.session.accessed = False

        i = self.session.iteritems()

        self.assertTrue(hasattr(i, '__iter__'))

        self.assertTrue(self.session.accessed)

        self.assertFalse(self.session.modified)

        self.assertEqual(list(i), [('x',1)])

    def test_clear(self):

        self.session['x'] = 1

        self.session.modified = False

        self.session.accessed = False

        self.assertEqual(self.session.items(), [('x',1)])

        self.session.clear()

        self.assertEqual(self.session.items(), [])

        self.assertTrue(self.session.accessed)

        self.assertTrue(self.session.modified)

    def test_save(self):

        self.session.save()

        self.assertTrue(self.session.exists(self.session.session_key))

    def test_delete(self):

        self.session.delete(self.session.session_key)

        self.assertFalse(self.session.exists(self.session.session_key))

    def test_flush(self):

        self.session['foo'] = 'bar'

        self.session.save()

        prev_key = self.session.session_key

        self.session.flush()

        self.assertFalse(self.session.exists(prev_key))

        self.assertNotEqual(self.session.session_key, prev_key)

        self.assertTrue(self.session.modified)

        self.assertTrue(self.session.accessed)

    def test_cycle(self):

        self.session['a'], self.session['b'] = 'c', 'd'

        self.session.save()

        prev_key = self.session.session_key

        prev_data = self.session.items()

        self.session.cycle_key()

        self.assertNotEqual(self.session.session_key, prev_key)

        self.assertEqual(self.session.items(), prev_data)

    def test_invalid_key(self):

        # Submitting an invalid session key (either by guessing, or if the db has

        # removed the key) results in a new key being generated.

>>> Session.objects.filter(pk=db_session.session_key).delete()

>>> db_session = DatabaseSession(db_session.session_key)

>>> db_session.save()

>>> DatabaseSession('1').get('cat')

#

# Cached DB session tests

#

>>> cdb_session = CacheDBSession()

>>> cdb_session.modified

False

>>> cdb_session['cat'] = "dog"

>>> cdb_session.modified

True

>>> cdb_session.pop('cat')

'dog'

>>> cdb_session.pop('some key', 'does not exist')

'does not exist'

>>> cdb_session.save()

>>> cdb_session.exists(cdb_session.session_key)

True

>>> cdb_session.delete(cdb_session.session_key)

>>> cdb_session.exists(cdb_session.session_key)

False

#

# File session tests.

#

        session = self.backend('1')

        session.save()

        self.assertNotEqual(session.session_key, '1')

        self.assertEqual(session.get('cat'), None)

        session.delete()

    # Custom session expiry

    def test_default_expiry(self):

        # A normal session has a max age equal to settings

        self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE)

        # So does a custom session with an idle expiration time of 0 (but it'll

        # expire at browser close)

        self.session.set_expiry(0)

        self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE)

    def test_custom_expiry_seconds(self):

        # Using seconds

        self.session.set_expiry(10)

        delta = self.session.get_expiry_date() - datetime.now()

        self.assertTrue(delta.seconds in (9, 10))

        age = self.session.get_expiry_age()

        self.assertTrue(age in (9, 10))

    def test_custom_expiry_timedelta(self):

        # Using timedelta

        self.session.set_expiry(timedelta(seconds=10))

        delta = self.session.get_expiry_date() - datetime.now()

        self.assertTrue(delta.seconds in (9, 10))

        age = self.session.get_expiry_age()

        self.assertTrue(age in (9, 10))

    def test_custom_expiry_timedelta(self):

        # Using timedelta

        self.session.set_expiry(datetime.now() + timedelta(seconds=10))

        delta = self.session.get_expiry_date() - datetime.now()

        self.assertTrue(delta.seconds in (9, 10))

        age = self.session.get_expiry_age()

        self.assertTrue(age in (9, 10))

    def test_custom_expiry_reset(self):

        self.session.set_expiry(None)

        self.session.set_expiry(10)

        self.session.set_expiry(None)

        self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE)

    def test_get_expire_at_browser_close(self):

        # Tests get_expire_at_browser_close with different settings and different

        # set_expiry calls

        try:

            original_expire_at_browser_close = settings.SESSION_EXPIRE_AT_BROWSER_CLOSE

            settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = False

            self.session.set_expiry(10)

            self.assertFalse(self.session.get_expire_at_browser_close())

            self.session.set_expiry(0)

            self.assertTrue(self.session.get_expire_at_browser_close())

            self.session.set_expiry(None)

            self.assertFalse(self.session.get_expire_at_browser_close())

            settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = True

            self.session.set_expiry(10)

            self.assertFalse(self.session.get_expire_at_browser_close())

            self.session.set_expiry(0)

            self.assertTrue(self.session.get_expire_at_browser_close())

            self.session.set_expiry(None)

            self.assertTrue(self.session.get_expire_at_browser_close())

        except:

            raise

        finally:

            settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = original_expire_at_browser_close

class DatabaseSessionTests(SessionTestsMixin, TestCase):

    backend = DatabaseSession

class CacheDBSessionTests(SessionTestsMixin, TestCase):

    backend = CacheDBSession

# Don't need DB flushing for these tests, so can use unittest.TestCase as base class

class FileSessionTests(SessionTestsMixin, unittest.TestCase):

    backend = FileSession

    def setUp(self):

        super(FileSessionTests, self).setUp()

        # Do file session tests in an isolated directory, and kill it after we're done.

>>> original_session_file_path = settings.SESSION_FILE_PATH

>>> import tempfile

>>> temp_session_store = settings.SESSION_FILE_PATH = tempfile.mkdtemp()

>>> file_session = FileSession()

>>> file_session.modified

False

>>> file_session['cat'] = "dog"

>>> file_session.modified

True

>>> file_session.pop('cat')

'dog'

>>> file_session.pop('some key', 'does not exist')

'does not exist'

>>> file_session.save()

>>> file_session.exists(file_session.session_key)

True

>>> file_session.delete(file_session.session_key)

>>> file_session.exists(file_session.session_key)

False

>>> FileSession('1').get('cat')

>>> file_session['foo'] = 'bar'

>>> file_session.save()

>>> file_session.exists(file_session.session_key)

True

>>> prev_key = file_session.session_key

>>> file_session.flush()

>>> file_session.exists(prev_key)

False

>>> file_session.session_key == prev_key

False

>>> file_session.modified, file_session.accessed

(True, True)

>>> file_session['a'], file_session['b'] = 'c', 'd'

>>> file_session.save()

>>> prev_key = file_session.session_key

>>> prev_data = file_session.items()

>>> file_session.cycle_key()

>>> file_session.session_key == prev_key

False

>>> file_session.items() == prev_data

True

>>> Session.objects.filter(pk=file_session.session_key).delete()

>>> file_session = FileSession(file_session.session_key)

>>> file_session.save()

        self.original_session_file_path = settings.SESSION_FILE_PATH

        self.temp_session_store = settings.SESSION_FILE_PATH = tempfile.mkdtemp()

    def tearDown(self):

        settings.SESSION_FILE_PATH = self.original_session_file_path

        shutil.rmtree(self.temp_session_store)

        super(FileSessionTests, self).tearDown()

    def test_configuration_check(self):

        # Make sure the file backend checks for a good storage dir

>>> settings.SESSION_FILE_PATH = "/if/this/directory/exists/you/have/a/weird/computer"

>>> FileSession()

Traceback (innermost last):

    ...

ImproperlyConfigured: The session storage path '/if/this/directory/exists/you/have/a/weird/computer' doesn't exist. Please set your SESSION_FILE_PATH setting to an existing directory in which Django can store session data.

# Clean up after the file tests

>>> settings.SESSION_FILE_PATH = original_session_file_path

>>> import shutil

>>> shutil.rmtree(temp_session_store)

#

# Cache-based tests

# NB: be careful to delete any sessions created; stale sessions fill up the

# /tmp and eventually overwhelm it after lots of runs (think buildbots)

#

>>> cache_session = CacheSession()

>>> cache_session.modified

False

>>> cache_session['cat'] = "dog"

>>> cache_session.modified

True

>>> cache_session.pop('cat')

'dog'

>>> cache_session.pop('some key', 'does not exist')

'does not exist'

>>> cache_session.save()

>>> cache_session.delete(cache_session.session_key)

>>> cache_session.exists(cache_session.session_key)

False

>>> cache_session['foo'] = 'bar'

>>> cache_session.save()

>>> cache_session.exists(cache_session.session_key)

True

>>> prev_key = cache_session.session_key

>>> cache_session.flush()

>>> cache_session.exists(prev_key)

False

>>> cache_session.session_key == prev_key

False

>>> cache_session.modified, cache_session.accessed

(True, True)

>>> cache_session['a'], cache_session['b'] = 'c', 'd'

>>> cache_session.save()

>>> prev_key = cache_session.session_key

>>> prev_data = cache_session.items()

>>> cache_session.cycle_key()

>>> cache_session.session_key == prev_key

False

>>> cache_session.items() == prev_data

True

>>> cache_session = CacheSession()

>>> cache_session.save()

>>> key = cache_session.session_key

>>> cache_session.exists(key)

True

>>> Session.objects.filter(pk=cache_session.session_key).delete()

>>> cache_session = CacheSession(cache_session.session_key)

>>> cache_session.save()

>>> cache_session.delete(cache_session.session_key)

>>> s = SessionBase()

>>> s._session['some key'] = 'exists' # Pre-populate the session with some data

>>> s.accessed = False   # Reset to pretend this wasn't accessed previously

>>> s.accessed, s.modified

(False, False)

>>> s.pop('non existant key', 'does not exist')

'does not exist'

>>> s.accessed, s.modified

(True, False)

>>> s.setdefault('foo', 'bar')

'bar'

>>> s.setdefault('foo', 'baz')

'bar'

>>> s.accessed = False  # Reset the accessed flag

>>> s.pop('some key')

'exists'

>>> s.accessed, s.modified

(True, True)

>>> s.pop('some key', 'does not exist')

'does not exist'

>>> s.get('update key', None)

# test .update()

>>> s.modified = s.accessed = False   # Reset to pretend this wasn't accessed previously

>>> s.update({'update key':1})

>>> s.accessed, s.modified

(True, True)

>>> s.get('update key', None)

1

# test .has_key()

>>> s.modified = s.accessed = False   # Reset to pretend this wasn't accessed previously

>>> s.has_key('update key')

True

>>> s.accessed, s.modified

(True, False)

# test .values()

>>> s = SessionBase()

>>> s.values()

[]

>>> s.accessed

True

>>> s['x'] = 1

>>> s.values()

[1]

# test .iterkeys()

>>> s.accessed = False

>>> i = s.iterkeys()

>>> hasattr(i,'__iter__')

True

>>> s.accessed

True

>>> list(i)

['x']

# test .itervalues()

>>> s.accessed = False

>>> i = s.itervalues()

>>> hasattr(i,'__iter__')

True

>>> s.accessed

True

>>> list(i)

[1]

# test .iteritems()

>>> s.accessed = False

>>> i = s.iteritems()

>>> hasattr(i,'__iter__')

True

>>> s.accessed

True

>>> list(i)

[('x', 1)]

# test .clear()

>>> s.modified = s.accessed = False

>>> s.items()

[('x', 1)]

>>> s.clear()

>>> s.items()

[]

>>> s.accessed, s.modified

(True, True)

#########################

# Custom session expiry #

#########################

>>> from django.conf import settings

>>> from datetime import datetime, timedelta

>>> td10 = timedelta(seconds=10)

        settings.SESSION_FILE_PATH = "/if/this/directory/exists/you/have/a/weird/computer"

        self.assertRaises(ImproperlyConfigured, self.backend)

# A normal session has a max age equal to settings

>>> s.get_expiry_age() == settings.SESSION_COOKIE_AGE

True

# So does a custom session with an idle expiration time of 0 (but it'll expire

# at browser close)

>>> s.set_expiry(0)

>>> s.get_expiry_age() == settings.SESSION_COOKIE_AGE

True

# Custom session idle expiration time

>>> s.set_expiry(10)

>>> delta = s.get_expiry_date() - datetime.now()

>>> delta.seconds in (9, 10)

True

>>> age = s.get_expiry_age()

>>> age in (9, 10)

True

# Custom session fixed expiry date (timedelta)

>>> s.set_expiry(td10)

>>> delta = s.get_expiry_date() - datetime.now()

>>> delta.seconds in (9, 10)

True

>>> age = s.get_expiry_age()

>>> age in (9, 10)

True

# Custom session fixed expiry date (fixed datetime)

>>> s.set_expiry(datetime.now() + td10)

>>> delta = s.get_expiry_date() - datetime.now()

>>> delta.seconds in (9, 10)

True

>>> age = s.get_expiry_age()

>>> age in (9, 10)

True

# Set back to default session age

>>> s.set_expiry(None)

>>> s.get_expiry_age() == settings.SESSION_COOKIE_AGE

True

# Allow to set back to default session age even if no alternate has been set

>>> s.set_expiry(None)

# We're changing the setting then reverting back to the original setting at the

# end of these tests.

>>> original_expire_at_browser_close = settings.SESSION_EXPIRE_AT_BROWSER_CLOSE

>>> settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = False

# Custom session age

>>> s.set_expiry(10)

>>> s.get_expire_at_browser_close()

False

# Custom expire-at-browser-close

>>> s.set_expiry(0)

>>> s.get_expire_at_browser_close()