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 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
|
||||
|
||||
# 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'
|
||||
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
|
||||
|
||||
|
||||
>>> s.get('update key', None)
|
||||
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.
|
||||
|
||||
# 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
|
||||
backend = None # subclasses must specify
|
||||
|
||||
# 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)
|
||||
def setUp(self):
|
||||
self.session = self.backend()
|
||||
|
||||
# test .values()
|
||||
>>> s = SessionBase()
|
||||
>>> s.values()
|
||||
[]
|
||||
>>> s.accessed
|
||||
True
|
||||
>>> s['x'] = 1
|
||||
>>> s.values()
|
||||
[1]
|
||||
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()
|
||||
|
||||
# test .iterkeys()
|
||||
>>> s.accessed = False
|
||||
>>> i = s.iterkeys()
|
||||
>>> hasattr(i,'__iter__')
|
||||
True
|
||||
>>> s.accessed
|
||||
True
|
||||
>>> list(i)
|
||||
['x']
|
||||
def test_new_session(self):
|
||||
self.assertFalse(self.session.modified)
|
||||
self.assertFalse(self.session.accessed)
|
||||
|
||||
# test .itervalues()
|
||||
>>> s.accessed = False
|
||||
>>> i = s.itervalues()
|
||||
>>> hasattr(i,'__iter__')
|
||||
True
|
||||
>>> s.accessed
|
||||
True
|
||||
>>> list(i)
|
||||
[1]
|
||||
def test_get_empty(self):
|
||||
self.assertEqual(self.session.get('cat'), None)
|
||||
|
||||
# test .iteritems()
|
||||
>>> s.accessed = False
|
||||
>>> i = s.iteritems()
|
||||
>>> hasattr(i,'__iter__')
|
||||
True
|
||||
>>> s.accessed
|
||||
True
|
||||
>>> list(i)
|
||||
[('x', 1)]
|
||||
def test_store(self):
|
||||
self.session['cat'] = "dog"
|
||||
self.assertTrue(self.session.modified)
|
||||
self.assertEqual(self.session.pop('cat'), 'dog')
|
||||
|
||||
# test .clear()
|
||||
>>> s.modified = s.accessed = False
|
||||
>>> s.items()
|
||||
[('x', 1)]
|
||||
>>> s.clear()
|
||||
>>> s.items()
|
||||
[]
|
||||
>>> s.accessed, s.modified
|
||||
(True, True)
|
||||
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
|
||||
|
||||
#########################
|
||||
# Custom session expiry #
|
||||
#########################
|
||||
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)
|
||||
|
||||
>>> from django.conf import settings
|
||||
>>> from datetime import datetime, timedelta
|
||||
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)
|
||||
|
||||
>>> td10 = timedelta(seconds=10)
|
||||
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)
|
||||
|
||||
# A normal session has a max age equal to settings
|
||||
>>> s.get_expiry_age() == settings.SESSION_COOKIE_AGE
|
||||
True
|
||||
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)
|
||||
|
||||
# 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
|
||||
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)
|
||||
|
||||
# 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_values(self):
|
||||
self.assertEqual(self.session.values(), [])
|
||||
self.assertTrue(self.session.accessed)
|
||||
self.session['some key'] = 1
|
||||
self.assertEqual(self.session.values(), [1])
|
||||
|
||||
# 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
|
||||
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'])
|
||||
|
||||
# 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_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])
|
||||
|
||||
# Set back to default session age
|
||||
>>> s.set_expiry(None)
|
||||
>>> s.get_expiry_age() == settings.SESSION_COOKIE_AGE
|
||||
True
|
||||
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)])
|
||||
|
||||
# Allow to set back to default session age even if no alternate has been set
|
||||
>>> s.set_expiry(None)
|
||||
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 = 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
|
||||
|
||||
|
||||
# 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