389 lines
9.5 KiB
Python
389 lines
9.5 KiB
Python
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'
|
|
|
|
|
|
>>> 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)
|
|
|
|
# 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()
|
|
True
|
|
|
|
# Default session age
|
|
>>> s.set_expiry(None)
|
|
>>> s.get_expire_at_browser_close()
|
|
False
|
|
|
|
>>> settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = True
|
|
|
|
# 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()
|
|
True
|
|
|
|
# Default session age
|
|
>>> s.set_expiry(None)
|
|
>>> s.get_expire_at_browser_close()
|
|
True
|
|
|
|
>>> settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = original_expire_at_browser_close
|
|
"""
|
|
|
|
if __name__ == '__main__':
|
|
import doctest
|
|
doctest.testmod()
|