1 r"""

     2 

     3 >>> from django.conf import settings

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

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

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

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

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

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

    10 

    11 >>> db_session = DatabaseSession()

    12 >>> db_session.modified

    13 False

    14 >>> db_session.get('cat')

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

    16 >>> db_session.modified

    17 True

    18 >>> db_session.pop('cat')

    19 'dog'

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

    21 'does not exist'

    22 >>> db_session.save()

    23 >>> db_session.exists(db_session.session_key)

    24 True

    25 >>> db_session.delete(db_session.session_key)

    26 >>> db_session.exists(db_session.session_key)

    27 False

    28 

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

    30 >>> db_session.save()

    31 >>> db_session.exists(db_session.session_key)

    32 True

    33 >>> prev_key = db_session.session_key

    34 >>> db_session.flush()

    35 >>> db_session.exists(prev_key)

    36 False

    37 >>> db_session.session_key == prev_key

    38 False

    39 >>> db_session.modified, db_session.accessed

    40 (True, True)

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

    42 >>> db_session.save()

    43 >>> prev_key = db_session.session_key

    44 >>> prev_data = db_session.items()

    45 >>> db_session.cycle_key()

    46 >>> db_session.session_key == prev_key

    47 False

    48 >>> db_session.items() == prev_data

    49 True

    50 

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

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

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

    54 >>> db_session = DatabaseSession(db_session.session_key)

    55 >>> db_session.save()

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

    57 

    58 #

    59 # Cached DB session tests

    60 #

    61 

    62 >>> cdb_session = CacheDBSession()

    63 >>> cdb_session.modified

    64 False

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

    66 >>> cdb_session.modified

    67 True

    68 >>> cdb_session.pop('cat')

    69 'dog'

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

    71 'does not exist'

    72 >>> cdb_session.save()

    73 >>> cdb_session.exists(cdb_session.session_key)

    74 True

    75 >>> cdb_session.delete(cdb_session.session_key)

    76 >>> cdb_session.exists(cdb_session.session_key)

    77 False

    78 

    79 #

    80 # File session tests.

    81 #

    82 

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

    84 >>> original_session_file_path = settings.SESSION_FILE_PATH

    85 >>> import tempfile

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

    87 

    88 >>> file_session = FileSession()

    89 >>> file_session.modified

    90 False

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

    92 >>> file_session.modified

    93 True

    94 >>> file_session.pop('cat')

    95 'dog'

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

    97 'does not exist'

    98 >>> file_session.save()

    99 >>> file_session.exists(file_session.session_key)

   100 True

   101 >>> file_session.delete(file_session.session_key)

   102 >>> file_session.exists(file_session.session_key)

   103 False

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

   105 

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

   107 >>> file_session.save()

   108 >>> file_session.exists(file_session.session_key)

   109 True

   110 >>> prev_key = file_session.session_key

   111 >>> file_session.flush()

   112 >>> file_session.exists(prev_key)

   113 False

   114 >>> file_session.session_key == prev_key

   115 False

   116 >>> file_session.modified, file_session.accessed

   117 (True, True)

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

   119 >>> file_session.save()

   120 >>> prev_key = file_session.session_key

   121 >>> prev_data = file_session.items()

   122 >>> file_session.cycle_key()

   123 >>> file_session.session_key == prev_key

   124 False

   125 >>> file_session.items() == prev_data

   126 True

   127 

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

   129 >>> file_session = FileSession(file_session.session_key)

   130 >>> file_session.save()

   131 

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

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

   134 >>> FileSession()

   135 Traceback (innermost last):

   136     ...

   137 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.

   138 

   139 # Clean up after the file tests

   140 >>> settings.SESSION_FILE_PATH = original_session_file_path

   141 >>> import shutil

   142 >>> shutil.rmtree(temp_session_store)

   143 

   144 #

   145 # Cache-based tests

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

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

   148 #

   149 

   150 >>> cache_session = CacheSession()

   151 >>> cache_session.modified

   152 False

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

   154 >>> cache_session.modified

   155 True

   156 >>> cache_session.pop('cat')

   157 'dog'

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

   159 'does not exist'

   160 >>> cache_session.save()

   161 >>> cache_session.delete(cache_session.session_key)

   162 >>> cache_session.exists(cache_session.session_key)

   163 False

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

   165 >>> cache_session.save()

   166 >>> cache_session.exists(cache_session.session_key)

   167 True

   168 >>> prev_key = cache_session.session_key

   169 >>> cache_session.flush()

   170 >>> cache_session.exists(prev_key)

   171 False

   172 >>> cache_session.session_key == prev_key

   173 False

   174 >>> cache_session.modified, cache_session.accessed

   175 (True, True)

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

   177 >>> cache_session.save()

   178 >>> prev_key = cache_session.session_key

   179 >>> prev_data = cache_session.items()

   180 >>> cache_session.cycle_key()

   181 >>> cache_session.session_key == prev_key

   182 False

   183 >>> cache_session.items() == prev_data

   184 True

   185 >>> cache_session = CacheSession()

   186 >>> cache_session.save()

   187 >>> key = cache_session.session_key

   188 >>> cache_session.exists(key)

   189 True

   190 

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

   192 >>> cache_session = CacheSession(cache_session.session_key)

   193 >>> cache_session.save()

   194 >>> cache_session.delete(cache_session.session_key)

   195 

   196 >>> s = SessionBase()

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

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

   199 

   200 >>> s.accessed, s.modified

   201 (False, False)

   202 

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

   204 'does not exist'

   205 >>> s.accessed, s.modified

   206 (True, False)

   207 

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

   209 'bar'

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

   211 'bar'

   212 

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

   214 

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

   216 'exists'

   217 >>> s.accessed, s.modified

   218 (True, True)

   219 

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

   221 'does not exist'

   222 

   223 

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

   225 

   226 # test .update()

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

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

   229 >>> s.accessed, s.modified

   230 (True, True)

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

   232 1

   233 

   234 # test .has_key()

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

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

   237 True

   238 >>> s.accessed, s.modified

   239 (True, False)

   240 

   241 # test .values()

   242 >>> s = SessionBase()

   243 >>> s.values()

   244 []

   245 >>> s.accessed

   246 True

   247 >>> s['x'] = 1

   248 >>> s.values()

   249 [1]

   250 

   251 # test .iterkeys()

   252 >>> s.accessed = False

   253 >>> i = s.iterkeys()

   254 >>> hasattr(i,'__iter__')

   255 True

   256 >>> s.accessed

   257 True

   258 >>> list(i)

   259 ['x']

   260 

   261 # test .itervalues()

   262 >>> s.accessed = False

   263 >>> i = s.itervalues()

   264 >>> hasattr(i,'__iter__')

   265 True

   266 >>> s.accessed

   267 True

   268 >>> list(i)

   269 [1]

   270 

   271 # test .iteritems()

   272 >>> s.accessed = False

   273 >>> i = s.iteritems()

   274 >>> hasattr(i,'__iter__')

   275 True

   276 >>> s.accessed

   277 True

   278 >>> list(i)

   279 [('x', 1)]

   280 

   281 # test .clear()

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

   283 >>> s.items()

   284 [('x', 1)]

   285 >>> s.clear()

   286 >>> s.items()

   287 []

   288 >>> s.accessed, s.modified

   289 (True, True)

   290 

   291 #########################

   292 # Custom session expiry #

   293 #########################

   294 

   295 >>> from django.conf import settings

   296 >>> from datetime import datetime, timedelta

   297 

   298 >>> td10 = timedelta(seconds=10)

   299 

   300 # A normal session has a max age equal to settings

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

   302 True

   303 

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

   305 # at browser close)

   306 >>> s.set_expiry(0)

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

   308 True

   309 

   310 # Custom session idle expiration time

   311 >>> s.set_expiry(10)

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

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

   314 True

   315 >>> age = s.get_expiry_age()

   316 >>> age in (9, 10)

   317 True

   318 

   319 # Custom session fixed expiry date (timedelta)

   320 >>> s.set_expiry(td10)

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

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

   323 True

   324 >>> age = s.get_expiry_age()

   325 >>> age in (9, 10)

   326 True

   327 

   328 # Custom session fixed expiry date (fixed datetime)

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

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

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

   332 True

   333 >>> age = s.get_expiry_age()

   334 >>> age in (9, 10)

   335 True

   336 

   337 # Set back to default session age

   338 >>> s.set_expiry(None)

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

   340 True

   341 

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

   343 >>> s.set_expiry(None)

   344 

   345 

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

   347 # end of these tests.

   348 >>> original_expire_at_browser_close = settings.SESSION_EXPIRE_AT_BROWSER_CLOSE

   349 >>> settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = False

   350 

   351 # Custom session age

   352 >>> s.set_expiry(10)

   353 >>> s.get_expire_at_browser_close()

   354 False

   355 

   356 # Custom expire-at-browser-close

   357 >>> s.set_expiry(0)

   358 >>> s.get_expire_at_browser_close()

   359 True

   360 

   361 # Default session age

   362 >>> s.set_expiry(None)

   363 >>> s.get_expire_at_browser_close()

   364 False

   365 

   366 >>> settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = True

   367 

   368 # Custom session age

   369 >>> s.set_expiry(10)

   370 >>> s.get_expire_at_browser_close()

   371 False

   372 

   373 # Custom expire-at-browser-close

   374 >>> s.set_expiry(0)

   375 >>> s.get_expire_at_browser_close()

   376 True

   377 

   378 # Default session age

   379 >>> s.set_expiry(None)

   380 >>> s.get_expire_at_browser_close()

   381 True

   382 

   383 >>> settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = original_expire_at_browser_close

   384 """

   385 

   386 if __name__ == '__main__':

   387     import doctest

   388     doctest.testmod()