mirror of https://github.com/django/django.git
Converted sessions tests from doctest to unittest.
Also made the FileSession backend consistent with other backends in one corner case uncovered by the conversion, namely that the backend should create a new key if the one passed in is invalid. git-svn-id: http://code.djangoproject.com/svn/django/trunk@13482 bcc190cf-cafb-0310-a4f2-bffc1f526a37
This commit is contained in:
Luke Plant
parent
c5e83a9e0a
commit
5eece23296
|
|
@ -58,7 +58,7 @@ class SessionStore(SessionBase):
|
|||
finally:
|
||||
session_file.close()
|
||||
except IOError:
|
||||
pass
|
||||
self.create()
|
||||
return session_data
|
||||
|
||||
def create(self):
|
||||
|
|
|
|||
|
|
@ -1,388 +1,273 @@
|
|||
r"""
|
||||
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
|
||||
|
||||
>>> 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
|
||||
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.
|
||||
|
||||
>>> 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
|
||||
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.
|
||||
#
|
||||
|
||||
# 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()
|
||||
|
||||
# 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)
|
||||
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
|
||||
>>> s.get_expiry_age() == settings.SESSION_COOKIE_AGE
|
||||
True
|
||||
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)
|
||||
>>> s.set_expiry(0)
|
||||
>>> 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)
|
||||
self.session.set_expiry(0)
|
||||
self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE)
|
||||
|
||||
# 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
|
||||
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))
|
||||
|
||||
# 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
|
||||
age = self.session.get_expiry_age()
|
||||
self.assertTrue(age in (9, 10))
|
||||
|
||||
# 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
|
||||
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))
|
||||
|
||||
# Set back to default session age
|
||||
>>> s.set_expiry(None)
|
||||
>>> s.get_expiry_age() == settings.SESSION_COOKIE_AGE
|
||||
True
|
||||
age = self.session.get_expiry_age()
|
||||
self.assertTrue(age in (9, 10))
|
||||
|
||||
# Allow to set back to default session age even if no alternate has been set
|
||||
>>> s.set_expiry(None)
|
||||
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
|
||||
|
||||
|
||||
# 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
|
||||
class DatabaseSessionTests(SessionTestsMixin, TestCase):
|
||||
|
||||
# Custom session age
|
||||
>>> s.set_expiry(10)
|
||||
>>> s.get_expire_at_browser_close()
|
||||
False
|
||||
backend = DatabaseSession
|
||||
|
||||
# Custom expire-at-browser-close
|
||||
>>> s.set_expiry(0)
|
||||
>>> s.get_expire_at_browser_close()
|
||||
True
|
||||
|
||||
# Default session age
|
||||
>>> s.set_expiry(None)
|
||||
>>> s.get_expire_at_browser_close()
|
||||
False
|
||||
class CacheDBSessionTests(SessionTestsMixin, TestCase):
|
||||
|
||||
>>> settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = True
|
||||
backend = CacheDBSession
|
||||
|
||||
# Custom session age
|
||||
>>> s.set_expiry(10)
|
||||
>>> s.get_expire_at_browser_close()
|
||||
False
|
||||
# Don't need DB flushing for these tests, so can use unittest.TestCase as base class
|
||||
class FileSessionTests(SessionTestsMixin, unittest.TestCase):
|
||||
|
||||
# Custom expire-at-browser-close
|
||||
>>> s.set_expiry(0)
|
||||
>>> s.get_expire_at_browser_close()
|
||||
True
|
||||
backend = FileSession
|
||||
|
||||
# Default session age
|
||||
>>> s.set_expiry(None)
|
||||
>>> s.get_expire_at_browser_close()
|
||||
True
|
||||
def setUp(self):
|
||||
super(FileSessionTests, self).setUp()
|
||||
# Do file session tests in an isolated directory, and kill it after we're done.
|
||||
self.original_session_file_path = settings.SESSION_FILE_PATH
|
||||
self.temp_session_store = settings.SESSION_FILE_PATH = tempfile.mkdtemp()
|
||||
|
||||
>>> settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = original_expire_at_browser_close
|
||||
"""
|
||||
def tearDown(self):
|
||||
settings.SESSION_FILE_PATH = self.original_session_file_path
|
||||
shutil.rmtree(self.temp_session_store)
|
||||
super(FileSessionTests, self).tearDown()
|
||||
|
||||
if __name__ == '__main__':
|
||||
import doctest
|
||||
doctest.testmod()
|
||||
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"
|
||||
self.assertRaises(ImproperlyConfigured, self.backend)
|
||||
|
||||
|
||||
class CacheSessionTests(SessionTestsMixin, unittest.TestCase):
|
||||
|
||||
backend = CacheSession
|
||||
|
|
|
|||
Loading…
Reference in New Issue