Debian Codegraph @

tests/sessions_tests/tests.py

raw
1 import base64
2 import os
3 import shutil
4 import string
5 import tempfile
6 import unittest
7 from datetime import timedelta
8 from http import cookies
9 from pathlib import Path
10 from unittest import mock
11
12 from django.conf import settings
13 from django.contrib.sessions.backends.base import SessionBase, UpdateError
14 from django.contrib.sessions.backends.cache import SessionStore as CacheSession
15 from django.contrib.sessions.backends.cached_db import SessionStore as CacheDBSession
16 from django.contrib.sessions.backends.db import SessionStore as DatabaseSession
17 from django.contrib.sessions.backends.file import SessionStore as FileSession
18 from django.contrib.sessions.backends.signed_cookies import (
19 SessionStore as CookieSession,
20 )
21 from django.contrib.sessions.exceptions import InvalidSessionKey, SessionInterrupted
22 from django.contrib.sessions.middleware import SessionMiddleware
23 from django.contrib.sessions.models import Session
24 from django.contrib.sessions.serializers import JSONSerializer
25 from django.core import management
26 from django.core.cache import caches
27 from django.core.cache.backends.base import InvalidCacheBackendError
28 from django.core.exceptions import ImproperlyConfigured
29 from django.core.signing import TimestampSigner
30 from django.http import HttpResponse
31 from django.test import (
32 RequestFactory,
33 SimpleTestCase,
34 TestCase,
35 ignore_warnings,
36 override_settings,
37 )
38 from django.utils import timezone
39
40 from .models import SessionStore as CustomDatabaseSession
41
42
43 class SessionTestsMixin:
44 # This does not inherit from TestCase to avoid any tests being run with this
45 # class, which wouldn't work, and to allow different TestCase subclasses to
46 # be used.
47
48 backend = None # subclasses must specify
49
50 def setUp(self):
51 self.session = self.backend()
52 # NB: be careful to delete any sessions created; stale sessions fill up
53 # the /tmp (with some backends) and eventually overwhelm it after lots
54 # of runs (think buildbots)
55 self.addCleanup(self.session.delete)
56
57 def test_new_session(self):
58 self.assertIs(self.session.modified, False)
59 self.assertIs(self.session.accessed, False)
60
61 def test_get_empty(self):
62 self.assertIsNone(self.session.get("cat"))
63
64 async def test_get_empty_async(self):
65 self.assertIsNone(await self.session.aget("cat"))
66
67 def test_store(self):
68 self.session["cat"] = "dog"
69 self.assertIs(self.session.modified, True)
70 self.assertEqual(self.session.pop("cat"), "dog")
71
72 async def test_store_async(self):
73 await self.session.aset("cat", "dog")
74 self.assertIs(self.session.modified, True)
75 self.assertEqual(await self.session.apop("cat"), "dog")
76
77 def test_pop(self):
78 self.session["some key"] = "exists"
79 # Need to reset these to pretend we haven't accessed it:
80 self.accessed = False
81 self.modified = False
82
83 self.assertEqual(self.session.pop("some key"), "exists")
84 self.assertIs(self.session.accessed, True)
85 self.assertIs(self.session.modified, True)
86 self.assertIsNone(self.session.get("some key"))
87
88 async def test_pop_async(self):
89 await self.session.aset("some key", "exists")
90 # Need to reset these to pretend we haven't accessed it:
91 self.accessed = False
92 self.modified = False
93
94 self.assertEqual(await self.session.apop("some key"), "exists")
95 self.assertIs(self.session.accessed, True)
96 self.assertIs(self.session.modified, True)
97 self.assertIsNone(await self.session.aget("some key"))
98
99 def test_pop_default(self):
100 self.assertEqual(
101 self.session.pop("some key", "does not exist"), "does not exist"
102 )
103 self.assertIs(self.session.accessed, True)
104 self.assertIs(self.session.modified, False)
105
106 async def test_pop_default_async(self):
107 self.assertEqual(
108 await self.session.apop("some key", "does not exist"), "does not exist"
109 )
110 self.assertIs(self.session.accessed, True)
111 self.assertIs(self.session.modified, False)
112
113 def test_pop_default_named_argument(self):
114 self.assertEqual(
115 self.session.pop("some key", default="does not exist"), "does not exist"
116 )
117 self.assertIs(self.session.accessed, True)
118 self.assertIs(self.session.modified, False)
119
120 async def test_pop_default_named_argument_async(self):
121 self.assertEqual(
122 await self.session.apop("some key", default="does not exist"),
123 "does not exist",
124 )
125 self.assertIs(self.session.accessed, True)
126 self.assertIs(self.session.modified, False)
127
128 def test_pop_no_default_keyerror_raised(self):
129 with self.assertRaises(KeyError):
130 self.session.pop("some key")
131
132 async def test_pop_no_default_keyerror_raised_async(self):
133 with self.assertRaises(KeyError):
134 await self.session.apop("some key")
135
136 def test_setdefault(self):
137 self.assertEqual(self.session.setdefault("foo", "bar"), "bar")
138 self.assertEqual(self.session.setdefault("foo", "baz"), "bar")
139 self.assertIs(self.session.accessed, True)
140 self.assertIs(self.session.modified, True)
141
142 async def test_setdefault_async(self):
143 self.assertEqual(await self.session.asetdefault("foo", "bar"), "bar")
144 self.assertEqual(await self.session.asetdefault("foo", "baz"), "bar")
145 self.assertIs(self.session.accessed, True)
146 self.assertIs(self.session.modified, True)
147
148 def test_update(self):
149 self.session.update({"update key": 1})
150 self.assertIs(self.session.accessed, True)
151 self.assertIs(self.session.modified, True)
152 self.assertEqual(self.session.get("update key", None), 1)
153
154 async def test_update_async(self):
155 await self.session.aupdate({"update key": 1})
156 self.assertIs(self.session.accessed, True)
157 self.assertIs(self.session.modified, True)
158 self.assertEqual(await self.session.aget("update key", None), 1)
159
160 def test_has_key(self):
161 self.session["some key"] = 1
162 self.session.modified = False
163 self.session.accessed = False
164 self.assertIn("some key", self.session)
165 self.assertIs(self.session.accessed, True)
166 self.assertIs(self.session.modified, False)
167
168 async def test_has_key_async(self):
169 await self.session.aset("some key", 1)
170 self.session.modified = False
171 self.session.accessed = False
172 self.assertIs(await self.session.ahas_key("some key"), True)
173 self.assertIs(self.session.accessed, True)
174 self.assertIs(self.session.modified, False)
175
176 def test_values(self):
177 self.assertEqual(list(self.session.values()), [])
178 self.assertIs(self.session.accessed, True)
179 self.session["some key"] = 1
180 self.session.modified = False
181 self.session.accessed = False
182 self.assertEqual(list(self.session.values()), [1])
183 self.assertIs(self.session.accessed, True)
184 self.assertIs(self.session.modified, False)
185
186 async def test_values_async(self):
187 self.assertEqual(list(await self.session.avalues()), [])
188 self.assertIs(self.session.accessed, True)
189 await self.session.aset("some key", 1)
190 self.session.modified = False
191 self.session.accessed = False
192 self.assertEqual(list(await self.session.avalues()), [1])
193 self.assertIs(self.session.accessed, True)
194 self.assertIs(self.session.modified, False)
195
196 def test_keys(self):
197 self.session["x"] = 1
198 self.session.modified = False
199 self.session.accessed = False
200 self.assertEqual(list(self.session.keys()), ["x"])
201 self.assertIs(self.session.accessed, True)
202 self.assertIs(self.session.modified, False)
203
204 async def test_keys_async(self):
205 await self.session.aset("x", 1)
206 self.session.modified = False
207 self.session.accessed = False
208 self.assertEqual(list(await self.session.akeys()), ["x"])
209 self.assertIs(self.session.accessed, True)
210 self.assertIs(self.session.modified, False)
211
212 def test_items(self):
213 self.session["x"] = 1
214 self.session.modified = False
215 self.session.accessed = False
216 self.assertEqual(list(self.session.items()), [("x", 1)])
217 self.assertIs(self.session.accessed, True)
218 self.assertIs(self.session.modified, False)
219
220 async def test_items_async(self):
221 await self.session.aset("x", 1)
222 self.session.modified = False
223 self.session.accessed = False
224 self.assertEqual(list(await self.session.aitems()), [("x", 1)])
225 self.assertIs(self.session.accessed, True)
226 self.assertIs(self.session.modified, False)
227
228 def test_clear(self):
229 self.session["x"] = 1
230 self.session.modified = False
231 self.session.accessed = False
232 self.assertEqual(list(self.session.items()), [("x", 1)])
233 self.session.clear()
234 self.assertEqual(list(self.session.items()), [])
235 self.assertIs(self.session.accessed, True)
236 self.assertIs(self.session.modified, True)
237
238 def test_save(self):
239 self.session.save()
240 self.assertIs(self.session.exists(self.session.session_key), True)
241
242 async def test_save_async(self):
243 await self.session.asave()
244 self.assertIs(await self.session.aexists(self.session.session_key), True)
245
246 def test_delete(self):
247 self.session.save()
248 self.session.delete(self.session.session_key)
249 self.assertIs(self.session.exists(self.session.session_key), False)
250
251 async def test_delete_async(self):
252 await self.session.asave()
253 await self.session.adelete(self.session.session_key)
254 self.assertIs(await self.session.aexists(self.session.session_key), False)
255
256 def test_flush(self):
257 self.session["foo"] = "bar"
258 self.session.save()
259 prev_key = self.session.session_key
260 self.session.flush()
261 self.assertIs(self.session.exists(prev_key), False)
262 self.assertNotEqual(self.session.session_key, prev_key)
263 self.assertIsNone(self.session.session_key)
264 self.assertIs(self.session.modified, True)
265 self.assertIs(self.session.accessed, True)
266
267 async def test_flush_async(self):
268 await self.session.aset("foo", "bar")
269 await self.session.asave()
270 prev_key = self.session.session_key
271 await self.session.aflush()
272 self.assertIs(await self.session.aexists(prev_key), False)
273 self.assertNotEqual(self.session.session_key, prev_key)
274 self.assertIsNone(self.session.session_key)
275 self.assertIs(self.session.modified, True)
276 self.assertIs(self.session.accessed, True)
277
278 def test_cycle(self):
279 self.session["a"], self.session["b"] = "c", "d"
280 self.session.save()
281 prev_key = self.session.session_key
282 prev_data = list(self.session.items())
283 self.session.cycle_key()
284 self.assertIs(self.session.exists(prev_key), False)
285 self.assertNotEqual(self.session.session_key, prev_key)
286 self.assertEqual(list(self.session.items()), prev_data)
287
288 async def test_cycle_async(self):
289 await self.session.aset("a", "c")
290 await self.session.aset("b", "d")
291 await self.session.asave()
292 prev_key = self.session.session_key
293 prev_data = list(await self.session.aitems())
294 await self.session.acycle_key()
295 self.assertIs(await self.session.aexists(prev_key), False)
296 self.assertNotEqual(self.session.session_key, prev_key)
297 self.assertEqual(list(await self.session.aitems()), prev_data)
298
299 def test_cycle_with_no_session_cache(self):
300 self.session["a"], self.session["b"] = "c", "d"
301 self.session.save()
302 prev_data = self.session.items()
303 self.session = self.backend(self.session.session_key)
304 self.assertIs(hasattr(self.session, "_session_cache"), False)
305 self.session.cycle_key()
306 self.assertCountEqual(self.session.items(), prev_data)
307
308 async def test_cycle_with_no_session_cache_async(self):
309 await self.session.aset("a", "c")
310 await self.session.aset("b", "d")
311 await self.session.asave()
312 prev_data = await self.session.aitems()
313 self.session = self.backend(self.session.session_key)
314 self.assertIs(hasattr(self.session, "_session_cache"), False)
315 await self.session.acycle_key()
316 self.assertCountEqual(await self.session.aitems(), prev_data)
317
318 def test_save_doesnt_clear_data(self):
319 self.session["a"] = "b"
320 self.session.save()
321 self.assertEqual(self.session["a"], "b")
322
323 async def test_save_doesnt_clear_data_async(self):
324 await self.session.aset("a", "b")
325 await self.session.asave()
326 self.assertEqual(await self.session.aget("a"), "b")
327
328 def test_invalid_key(self):
329 # Submitting an invalid session key (either by guessing, or if the db has
330 # removed the key) results in a new key being generated.
331 try:
332 session = self.backend("1")
333 session.save()
334 self.assertNotEqual(session.session_key, "1")
335 self.assertIsNone(session.get("cat"))
336 session.delete()
337 finally:
338 # Some backends leave a stale cache entry for the invalid
339 # session key; make sure that entry is manually deleted
340 session.delete("1")
341
342 async def test_invalid_key_async(self):
343 # Submitting an invalid session key (either by guessing, or if the db has
344 # removed the key) results in a new key being generated.
345 try:
346 session = self.backend("1")
347 await session.asave()
348 self.assertNotEqual(session.session_key, "1")
349 self.assertIsNone(await session.aget("cat"))
350 await session.adelete()
351 finally:
352 # Some backends leave a stale cache entry for the invalid
353 # session key; make sure that entry is manually deleted
354 await session.adelete("1")
355
356 def test_session_key_empty_string_invalid(self):
357 """Falsey values (Such as an empty string) are rejected."""
358 self.session._session_key = ""
359 self.assertIsNone(self.session.session_key)
360
361 def test_session_key_too_short_invalid(self):
362 """Strings shorter than 8 characters are rejected."""
363 self.session._session_key = "1234567"
364 self.assertIsNone(self.session.session_key)
365
366 def test_session_key_valid_string_saved(self):
367 """Strings of length 8 and up are accepted and stored."""
368 self.session._session_key = "12345678"
369 self.assertEqual(self.session.session_key, "12345678")
370
371 def test_session_key_is_read_only(self):
372 def set_session_key(session):
373 session.session_key = session._get_new_session_key()
374
375 with self.assertRaises(AttributeError):
376 set_session_key(self.session)
377
378 # Custom session expiry
379 def test_default_expiry(self):
380 # A normal session has a max age equal to settings
381 self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE)
382
383 # So does a custom session with an idle expiration time of 0 (but it'll
384 # expire at browser close)
385 self.session.set_expiry(0)
386 self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE)
387
388 async def test_default_expiry_async(self):
389 # A normal session has a max age equal to settings.
390 self.assertEqual(
391 await self.session.aget_expiry_age(), settings.SESSION_COOKIE_AGE
392 )
393 # So does a custom session with an idle expiration time of 0 (but it'll
394 # expire at browser close).
395 await self.session.aset_expiry(0)
396 self.assertEqual(
397 await self.session.aget_expiry_age(), settings.SESSION_COOKIE_AGE
398 )
399
400 def test_custom_expiry_seconds(self):
401 modification = timezone.now()
402
403 self.session.set_expiry(10)
404
405 date = self.session.get_expiry_date(modification=modification)
406 self.assertEqual(date, modification + timedelta(seconds=10))
407
408 age = self.session.get_expiry_age(modification=modification)
409 self.assertEqual(age, 10)
410
411 async def test_custom_expiry_seconds_async(self):
412 modification = timezone.now()
413
414 await self.session.aset_expiry(10)
415
416 date = await self.session.aget_expiry_date(modification=modification)
417 self.assertEqual(date, modification + timedelta(seconds=10))
418
419 age = await self.session.aget_expiry_age(modification=modification)
420 self.assertEqual(age, 10)
421
422 def test_custom_expiry_timedelta(self):
423 modification = timezone.now()
424
425 # Mock timezone.now, because set_expiry calls it on this code path.
426 original_now = timezone.now
427 try:
428 timezone.now = lambda: modification
429 self.session.set_expiry(timedelta(seconds=10))
430 finally:
431 timezone.now = original_now
432
433 date = self.session.get_expiry_date(modification=modification)
434 self.assertEqual(date, modification + timedelta(seconds=10))
435
436 age = self.session.get_expiry_age(modification=modification)
437 self.assertEqual(age, 10)
438
439 async def test_custom_expiry_timedelta_async(self):
440 modification = timezone.now()
441
442 # Mock timezone.now, because set_expiry calls it on this code path.
443 original_now = timezone.now
444 try:
445 timezone.now = lambda: modification
446 await self.session.aset_expiry(timedelta(seconds=10))
447 finally:
448 timezone.now = original_now
449
450 date = await self.session.aget_expiry_date(modification=modification)
451 self.assertEqual(date, modification + timedelta(seconds=10))
452
453 age = await self.session.aget_expiry_age(modification=modification)
454 self.assertEqual(age, 10)
455
456 def test_custom_expiry_datetime(self):
457 modification = timezone.now()
458
459 self.session.set_expiry(modification + timedelta(seconds=10))
460
461 date = self.session.get_expiry_date(modification=modification)
462 self.assertEqual(date, modification + timedelta(seconds=10))
463
464 age = self.session.get_expiry_age(modification=modification)
465 self.assertEqual(age, 10)
466
467 async def test_custom_expiry_datetime_async(self):
468 modification = timezone.now()
469
470 await self.session.aset_expiry(modification + timedelta(seconds=10))
471
472 date = await self.session.aget_expiry_date(modification=modification)
473 self.assertEqual(date, modification + timedelta(seconds=10))
474
475 age = await self.session.aget_expiry_age(modification=modification)
476 self.assertEqual(age, 10)
477
478 def test_custom_expiry_reset(self):
479 self.session.set_expiry(None)
480 self.session.set_expiry(10)
481 self.session.set_expiry(None)
482 self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE)
483
484 async def test_custom_expiry_reset_async(self):
485 await self.session.aset_expiry(None)
486 await self.session.aset_expiry(10)
487 await self.session.aset_expiry(None)
488 self.assertEqual(
489 await self.session.aget_expiry_age(), settings.SESSION_COOKIE_AGE
490 )
491
492 def test_get_expire_at_browser_close(self):
493 # Tests get_expire_at_browser_close with different settings and different
494 # set_expiry calls
495 with override_settings(SESSION_EXPIRE_AT_BROWSER_CLOSE=False):
496 self.session.set_expiry(10)
497 self.assertIs(self.session.get_expire_at_browser_close(), False)
498
499 self.session.set_expiry(0)
500 self.assertIs(self.session.get_expire_at_browser_close(), True)
501
502 self.session.set_expiry(None)
503 self.assertIs(self.session.get_expire_at_browser_close(), False)
504
505 with override_settings(SESSION_EXPIRE_AT_BROWSER_CLOSE=True):
506 self.session.set_expiry(10)
507 self.assertIs(self.session.get_expire_at_browser_close(), False)
508
509 self.session.set_expiry(0)
510 self.assertIs(self.session.get_expire_at_browser_close(), True)
511
512 self.session.set_expiry(None)
513 self.assertIs(self.session.get_expire_at_browser_close(), True)
514
515 async def test_get_expire_at_browser_close_async(self):
516 # Tests get_expire_at_browser_close with different settings and different
517 # set_expiry calls
518 with override_settings(SESSION_EXPIRE_AT_BROWSER_CLOSE=False):
519 await self.session.aset_expiry(10)
520 self.assertIs(await self.session.aget_expire_at_browser_close(), False)
521
522 await self.session.aset_expiry(0)
523 self.assertIs(await self.session.aget_expire_at_browser_close(), True)
524
525 await self.session.aset_expiry(None)
526 self.assertIs(await self.session.aget_expire_at_browser_close(), False)
527
528 with override_settings(SESSION_EXPIRE_AT_BROWSER_CLOSE=True):
529 await self.session.aset_expiry(10)
530 self.assertIs(await self.session.aget_expire_at_browser_close(), False)
531
532 await self.session.aset_expiry(0)
533 self.assertIs(await self.session.aget_expire_at_browser_close(), True)
534
535 await self.session.aset_expiry(None)
536 self.assertIs(await self.session.aget_expire_at_browser_close(), True)
537
538 def test_decode(self):
539 # Ensure we can decode what we encode
540 data = {"a test key": "a test value"}
541 encoded = self.session.encode(data)
542 self.assertEqual(self.session.decode(encoded), data)
543
544 def test_decode_failure_logged_to_security(self):
545 tests = [
546 base64.b64encode(b"flaskdj:alkdjf").decode("ascii"),
547 "bad:encoded:value",
548 ]
549 for encoded in tests:
550 with self.subTest(encoded=encoded):
551 with self.assertLogs(
552 "django.security.SuspiciousSession", "WARNING"
553 ) as cm:
554 self.assertEqual(self.session.decode(encoded), {})
555 # The failed decode is logged.
556 self.assertIn("Session data corrupted", cm.output[0])
557
558 def test_decode_serializer_exception(self):
559 signer = TimestampSigner(salt=self.session.key_salt)
560 encoded = signer.sign(b"invalid data")
561 self.assertEqual(self.session.decode(encoded), {})
562
563 def test_actual_expiry(self):
564 old_session_key = None
565 new_session_key = None
566 try:
567 self.session["foo"] = "bar"
568 self.session.set_expiry(-timedelta(seconds=10))
569 self.session.save()
570 old_session_key = self.session.session_key
571 # With an expiry date in the past, the session expires instantly.
572 new_session = self.backend(self.session.session_key)
573 new_session_key = new_session.session_key
574 self.assertNotIn("foo", new_session)
575 finally:
576 self.session.delete(old_session_key)
577 self.session.delete(new_session_key)
578
579 async def test_actual_expiry_async(self):
580 old_session_key = None
581 new_session_key = None
582 try:
583 await self.session.aset("foo", "bar")
584 await self.session.aset_expiry(-timedelta(seconds=10))
585 await self.session.asave()
586 old_session_key = self.session.session_key
587 # With an expiry date in the past, the session expires instantly.
588 new_session = self.backend(self.session.session_key)
589 new_session_key = new_session.session_key
590 self.assertIs(await new_session.ahas_key("foo"), False)
591 finally:
592 await self.session.adelete(old_session_key)
593 await self.session.adelete(new_session_key)
594
595 def test_session_load_does_not_create_record(self):
596 """
597 Loading an unknown session key does not create a session record.
598
599 Creating session records on load is a DOS vulnerability.
600 """
601 session = self.backend("someunknownkey")
602 session.load()
603
604 self.assertIsNone(session.session_key)
605 self.assertIs(session.exists(session.session_key), False)
606 # provided unknown key was cycled, not reused
607 self.assertNotEqual(session.session_key, "someunknownkey")
608
609 async def test_session_load_does_not_create_record_async(self):
610 session = self.backend("someunknownkey")
611 await session.aload()
612
613 self.assertIsNone(session.session_key)
614 self.assertIs(await session.aexists(session.session_key), False)
615 # Provided unknown key was cycled, not reused.
616 self.assertNotEqual(session.session_key, "someunknownkey")
617
618 def test_session_save_does_not_resurrect_session_logged_out_in_other_context(self):
619 """
620 Sessions shouldn't be resurrected by a concurrent request.
621 """
622 # Create new session.
623 s1 = self.backend()
624 s1["test_data"] = "value1"
625 s1.save(must_create=True)
626
627 # Logout in another context.
628 s2 = self.backend(s1.session_key)
629 s2.delete()
630
631 # Modify session in first context.
632 s1["test_data"] = "value2"
633 with self.assertRaises(UpdateError):
634 # This should throw an exception as the session is deleted, not
635 # resurrect the session.
636 s1.save()
637
638 self.assertEqual(s1.load(), {})
639
640 async def test_session_asave_does_not_resurrect_session_logged_out_in_other_context(
641 self,
642 ):
643 """Sessions shouldn't be resurrected by a concurrent request."""
644 # Create new session.
645 s1 = self.backend()
646 await s1.aset("test_data", "value1")
647 await s1.asave(must_create=True)
648
649 # Logout in another context.
650 s2 = self.backend(s1.session_key)
651 await s2.adelete()
652
653 # Modify session in first context.
654 await s1.aset("test_data", "value2")
655 with self.assertRaises(UpdateError):
656 # This should throw an exception as the session is deleted, not
657 # resurrect the session.
658 await s1.asave()
659
660 self.assertEqual(await s1.aload(), {})
661
662
663 class DatabaseSessionTests(SessionTestsMixin, TestCase):
664 backend = DatabaseSession
665 session_engine = "django.contrib.sessions.backends.db"
666
667 @property
668 def model(self):
669 return self.backend.get_model_class()
670
671 def test_session_str(self):
672 "Session repr should be the session key."
673 self.session["x"] = 1
674 self.session.save()
675
676 session_key = self.session.session_key
677 s = self.model.objects.get(session_key=session_key)
678
679 self.assertEqual(str(s), session_key)
680
681 def test_session_get_decoded(self):
682 """
683 Test we can use Session.get_decoded to retrieve data stored
684 in normal way
685 """
686 self.session["x"] = 1
687 self.session.save()
688
689 s = self.model.objects.get(session_key=self.session.session_key)
690
691 self.assertEqual(s.get_decoded(), {"x": 1})
692
693 def test_sessionmanager_save(self):
694 """
695 Test SessionManager.save method
696 """
697 # Create a session
698 self.session["y"] = 1
699 self.session.save()
700
701 s = self.model.objects.get(session_key=self.session.session_key)
702 # Change it
703 self.model.objects.save(s.session_key, {"y": 2}, s.expire_date)
704 # Clear cache, so that it will be retrieved from DB
705 del self.session._session_cache
706 self.assertEqual(self.session["y"], 2)
707
708 def test_clearsessions_command(self):
709 """
710 Test clearsessions command for clearing expired sessions.
711 """
712 self.assertEqual(0, self.model.objects.count())
713
714 # One object in the future
715 self.session["foo"] = "bar"
716 self.session.set_expiry(3600)
717 self.session.save()
718
719 # One object in the past
720 other_session = self.backend()
721 other_session["foo"] = "bar"
722 other_session.set_expiry(-3600)
723 other_session.save()
724
725 # Two sessions are in the database before clearsessions...
726 self.assertEqual(2, self.model.objects.count())
727 with override_settings(SESSION_ENGINE=self.session_engine):
728 management.call_command("clearsessions")
729 # ... and one is deleted.
730 self.assertEqual(1, self.model.objects.count())
731
732 async def test_aclear_expired(self):
733 self.assertEqual(await self.model.objects.acount(), 0)
734
735 # Object in the future.
736 await self.session.aset("key", "value")
737 await self.session.aset_expiry(3600)
738 await self.session.asave()
739 # Object in the past.
740 other_session = self.backend()
741 await other_session.aset("key", "value")
742 await other_session.aset_expiry(-3600)
743 await other_session.asave()
744
745 # Two sessions are in the database before clearing expired.
746 self.assertEqual(await self.model.objects.acount(), 2)
747 await self.session.aclear_expired()
748 await other_session.aclear_expired()
749 self.assertEqual(await self.model.objects.acount(), 1)
750
751
752 @override_settings(USE_TZ=True)
753 class DatabaseSessionWithTimeZoneTests(DatabaseSessionTests):
754 pass
755
756
757 class CustomDatabaseSessionTests(DatabaseSessionTests):
758 backend = CustomDatabaseSession
759 session_engine = "sessions_tests.models"
760 custom_session_cookie_age = 60 * 60 * 24 # One day.
761
762 def test_extra_session_field(self):
763 # Set the account ID to be picked up by a custom session storage
764 # and saved to a custom session model database column.
765 self.session["_auth_user_id"] = 42
766 self.session.save()
767
768 # Make sure that the customized create_model_instance() was called.
769 s = self.model.objects.get(session_key=self.session.session_key)
770 self.assertEqual(s.account_id, 42)
771
772 # Make the session "anonymous".
773 self.session.pop("_auth_user_id")
774 self.session.save()
775
776 # Make sure that save() on an existing session did the right job.
777 s = self.model.objects.get(session_key=self.session.session_key)
778 self.assertIsNone(s.account_id)
779
780 def test_custom_expiry_reset(self):
781 self.session.set_expiry(None)
782 self.session.set_expiry(10)
783 self.session.set_expiry(None)
784 self.assertEqual(self.session.get_expiry_age(), self.custom_session_cookie_age)
785
786 async def test_custom_expiry_reset_async(self):
787 await self.session.aset_expiry(None)
788 await self.session.aset_expiry(10)
789 await self.session.aset_expiry(None)
790 self.assertEqual(
791 await self.session.aget_expiry_age(), self.custom_session_cookie_age
792 )
793
794 def test_default_expiry(self):
795 self.assertEqual(self.session.get_expiry_age(), self.custom_session_cookie_age)
796 self.session.set_expiry(0)
797 self.assertEqual(self.session.get_expiry_age(), self.custom_session_cookie_age)
798
799 async def test_default_expiry_async(self):
800 self.assertEqual(
801 await self.session.aget_expiry_age(), self.custom_session_cookie_age
802 )
803 await self.session.aset_expiry(0)
804 self.assertEqual(
805 await self.session.aget_expiry_age(), self.custom_session_cookie_age
806 )
807
808
809 class CacheDBSessionTests(SessionTestsMixin, TestCase):
810 backend = CacheDBSession
811
812 def test_exists_searches_cache_first(self):
813 self.session.save()
814 with self.assertNumQueries(0):
815 self.assertIs(self.session.exists(self.session.session_key), True)
816
817 # Some backends might issue a warning
818 @ignore_warnings(module="django.core.cache.backends.base")
819 def test_load_overlong_key(self):
820 self.session._session_key = (string.ascii_letters + string.digits) * 20
821 self.assertEqual(self.session.load(), {})
822
823 @override_settings(SESSION_CACHE_ALIAS="sessions")
824 def test_non_default_cache(self):
825 # 21000 - CacheDB backend should respect SESSION_CACHE_ALIAS.
826 with self.assertRaises(InvalidCacheBackendError):
827 self.backend()
828
829 @override_settings(
830 CACHES={"default": {"BACKEND": "cache.failing_cache.CacheClass"}}
831 )
832 def test_cache_set_failure_non_fatal(self):
833 """Failing to write to the cache does not raise errors."""
834 session = self.backend()
835 session["key"] = "val"
836
837 with self.assertLogs("django.contrib.sessions", "ERROR") as cm:
838 session.save()
839
840 # A proper ERROR log message was recorded.
841 log = cm.records[-1]
842 self.assertEqual(log.message, f"Error saving to cache ({session._cache})")
843 self.assertEqual(str(log.exc_info[1]), "Faked exception saving to cache")
844
845 @override_settings(
846 CACHES={"default": {"BACKEND": "cache.failing_cache.CacheClass"}}
847 )
848 async def test_cache_async_set_failure_non_fatal(self):
849 """Failing to write to the cache does not raise errors."""
850 session = self.backend()
851 await session.aset("key", "val")
852
853 with self.assertLogs("django.contrib.sessions", "ERROR") as cm:
854 await session.asave()
855
856 # A proper ERROR log message was recorded.
857 log = cm.records[-1]
858 self.assertEqual(log.message, f"Error saving to cache ({session._cache})")
859 self.assertEqual(str(log.exc_info[1]), "Faked exception saving to cache")
860
861
862 @override_settings(USE_TZ=True)
863 class CacheDBSessionWithTimeZoneTests(CacheDBSessionTests):
864 pass
865
866
867 class FileSessionTests(SessionTestsMixin, SimpleTestCase):
868 backend = FileSession
869
870 def setUp(self):
871 # Do file session tests in an isolated directory, and kill it after we're done.
872 self.original_session_file_path = settings.SESSION_FILE_PATH
873 self.temp_session_store = settings.SESSION_FILE_PATH = self.mkdtemp()
874 self.addCleanup(shutil.rmtree, self.temp_session_store)
875 # Reset the file session backend's internal caches
876 if hasattr(self.backend, "_storage_path"):
877 del self.backend._storage_path
878 super().setUp()
879
880 def tearDown(self):
881 super().tearDown()
882 settings.SESSION_FILE_PATH = self.original_session_file_path
883
884 def mkdtemp(self):
885 return tempfile.mkdtemp()
886
887 @override_settings(
888 SESSION_FILE_PATH="/if/this/directory/exists/you/have/a/weird/computer",
889 )
890 def test_configuration_check(self):
891 del self.backend._storage_path
892 # Make sure the file backend checks for a good storage dir
893 with self.assertRaises(ImproperlyConfigured):
894 self.backend()
895
896 def test_invalid_key_backslash(self):
897 # Ensure we don't allow directory-traversal.
898 # This is tested directly on _key_to_file, as load() will swallow
899 # a SuspiciousOperation in the same way as an OSError - by creating
900 # a new session, making it unclear whether the slashes were detected.
901 with self.assertRaises(InvalidSessionKey):
902 self.backend()._key_to_file("a\\b\\c")
903
904 def test_invalid_key_forwardslash(self):
905 # Ensure we don't allow directory-traversal
906 with self.assertRaises(InvalidSessionKey):
907 self.backend()._key_to_file("a/b/c")
908
909 @override_settings(
910 SESSION_ENGINE="django.contrib.sessions.backends.file",
911 SESSION_COOKIE_AGE=0,
912 )
913 def test_clearsessions_command(self):
914 """
915 Test clearsessions command for clearing expired sessions.
916 """
917 storage_path = self.backend._get_storage_path()
918 file_prefix = settings.SESSION_COOKIE_NAME
919
920 def count_sessions():
921 return len(
922 [
923 session_file
924 for session_file in os.listdir(storage_path)
925 if session_file.startswith(file_prefix)
926 ]
927 )
928
929 self.assertEqual(0, count_sessions())
930
931 # One object in the future
932 self.session["foo"] = "bar"
933 self.session.set_expiry(3600)
934 self.session.save()
935
936 # One object in the past
937 other_session = self.backend()
938 other_session["foo"] = "bar"
939 other_session.set_expiry(-3600)
940 other_session.save()
941
942 # One object in the present without an expiry (should be deleted since
943 # its modification time + SESSION_COOKIE_AGE will be in the past when
944 # clearsessions runs).
945 other_session2 = self.backend()
946 other_session2["foo"] = "bar"
947 other_session2.save()
948
949 # Three sessions are in the filesystem before clearsessions...
950 self.assertEqual(3, count_sessions())
951 management.call_command("clearsessions")
952 # ... and two are deleted.
953 self.assertEqual(1, count_sessions())
954
955
956 class FileSessionPathLibTests(FileSessionTests):
957 def mkdtemp(self):
958 tmp_dir = super().mkdtemp()
959 return Path(tmp_dir)
960
961
962 class CacheSessionTests(SessionTestsMixin, SimpleTestCase):
963 backend = CacheSession
964
965 # Some backends might issue a warning
966 @ignore_warnings(module="django.core.cache.backends.base")
967 def test_load_overlong_key(self):
968 self.session._session_key = (string.ascii_letters + string.digits) * 20
969 self.assertEqual(self.session.load(), {})
970
971 def test_default_cache(self):
972 self.session.save()
973 self.assertIsNotNone(caches["default"].get(self.session.cache_key))
974
975 @override_settings(
976 CACHES={
977 "default": {
978 "BACKEND": "django.core.cache.backends.dummy.DummyCache",
979 },
980 "sessions": {
981 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
982 "LOCATION": "session",
983 },
984 },
985 SESSION_CACHE_ALIAS="sessions",
986 )
987 def test_non_default_cache(self):
988 # Re-initialize the session backend to make use of overridden settings.
989 self.session = self.backend()
990
991 self.session.save()
992 self.assertIsNone(caches["default"].get(self.session.cache_key))
993 self.assertIsNotNone(caches["sessions"].get(self.session.cache_key))
994
995 def test_create_and_save(self):
996 self.session = self.backend()
997 self.session.create()
998 self.session.save()
999 self.assertIsNotNone(caches["default"].get(self.session.cache_key))
1000
1001 async def test_create_and_save_async(self):
1002 self.session = self.backend()
1003 await self.session.acreate()
1004 await self.session.asave()
1005 self.assertIsNotNone(caches["default"].get(await self.session.acache_key()))
1006
1007
1008 class SessionMiddlewareTests(TestCase):
1009 request_factory = RequestFactory()
1010
1011 @staticmethod
1012 def get_response_touching_session(request):
1013 request.session["hello"] = "world"
1014 return HttpResponse("Session test")
1015
1016 @override_settings(SESSION_COOKIE_SECURE=True)
1017 def test_secure_session_cookie(self):
1018 request = self.request_factory.get("/")
1019 middleware = SessionMiddleware(self.get_response_touching_session)
1020
1021 # Handle the response through the middleware
1022 response = middleware(request)
1023 self.assertIs(response.cookies[settings.SESSION_COOKIE_NAME]["secure"], True)
1024 self.assertEqual(response.headers["Vary"], "Cookie")
1025
1026 @override_settings(SESSION_COOKIE_HTTPONLY=True)
1027 def test_httponly_session_cookie(self):
1028 request = self.request_factory.get("/")
1029 middleware = SessionMiddleware(self.get_response_touching_session)
1030
1031 # Handle the response through the middleware
1032 response = middleware(request)
1033 self.assertIs(response.cookies[settings.SESSION_COOKIE_NAME]["httponly"], True)
1034 self.assertIn(
1035 cookies.Morsel._reserved["httponly"],
1036 str(response.cookies[settings.SESSION_COOKIE_NAME]),
1037 )
1038
1039 @override_settings(SESSION_COOKIE_SAMESITE="Strict")
1040 def test_samesite_session_cookie(self):
1041 request = self.request_factory.get("/")
1042 middleware = SessionMiddleware(self.get_response_touching_session)
1043 response = middleware(request)
1044 self.assertEqual(
1045 response.cookies[settings.SESSION_COOKIE_NAME]["samesite"], "Strict"
1046 )
1047
1048 @override_settings(SESSION_COOKIE_HTTPONLY=False)
1049 def test_no_httponly_session_cookie(self):
1050 request = self.request_factory.get("/")
1051 middleware = SessionMiddleware(self.get_response_touching_session)
1052 response = middleware(request)
1053 self.assertEqual(response.cookies[settings.SESSION_COOKIE_NAME]["httponly"], "")
1054 self.assertNotIn(
1055 cookies.Morsel._reserved["httponly"],
1056 str(response.cookies[settings.SESSION_COOKIE_NAME]),
1057 )
1058
1059 def test_session_save_on_500(self):
1060 def response_500(request):
1061 response = HttpResponse("Horrible error")
1062 response.status_code = 500
1063 request.session["hello"] = "world"
1064 return response
1065
1066 request = self.request_factory.get("/")
1067 SessionMiddleware(response_500)(request)
1068
1069 # The value wasn't saved above.
1070 self.assertNotIn("hello", request.session.load())
1071
1072 def test_session_save_on_5xx(self):
1073 def response_503(request):
1074 response = HttpResponse("Service Unavailable")
1075 response.status_code = 503
1076 request.session["hello"] = "world"
1077 return response
1078
1079 request = self.request_factory.get("/")
1080 SessionMiddleware(response_503)(request)
1081
1082 # The value wasn't saved above.
1083 self.assertNotIn("hello", request.session.load())
1084
1085 def test_session_update_error_redirect(self):
1086 def response_delete_session(request):
1087 request.session = DatabaseSession()
1088 request.session.save(must_create=True)
1089 request.session.delete()
1090 return HttpResponse()
1091
1092 request = self.request_factory.get("/foo/")
1093 middleware = SessionMiddleware(response_delete_session)
1094
1095 msg = (
1096 "The request's session was deleted before the request completed. "
1097 "The user may have logged out in a concurrent request, for example."
1098 )
1099 with self.assertRaisesMessage(SessionInterrupted, msg):
1100 # Handle the response through the middleware. It will try to save
1101 # the deleted session which will cause an UpdateError that's caught
1102 # and raised as a SessionInterrupted.
1103 middleware(request)
1104
1105 def test_session_delete_on_end(self):
1106 def response_ending_session(request):
1107 request.session.flush()
1108 return HttpResponse("Session test")
1109
1110 request = self.request_factory.get("/")
1111 middleware = SessionMiddleware(response_ending_session)
1112
1113 # Before deleting, there has to be an existing cookie
1114 request.COOKIES[settings.SESSION_COOKIE_NAME] = "abc"
1115
1116 # Handle the response through the middleware
1117 response = middleware(request)
1118
1119 # The cookie was deleted, not recreated.
1120 # A deleted cookie header looks like:
1121 # "Set-Cookie: sessionid=; expires=Thu, 01 Jan 1970 00:00:00 GMT; "
1122 # "Max-Age=0; Path=/"
1123 self.assertEqual(
1124 'Set-Cookie: {}=""; expires=Thu, 01 Jan 1970 00:00:00 GMT; '
1125 "Max-Age=0; Path=/; SameSite={}".format(
1126 settings.SESSION_COOKIE_NAME,
1127 settings.SESSION_COOKIE_SAMESITE,
1128 ),
1129 str(response.cookies[settings.SESSION_COOKIE_NAME]),
1130 )
1131 # SessionMiddleware sets 'Vary: Cookie' to prevent the 'Set-Cookie'
1132 # from being cached.
1133 self.assertEqual(response.headers["Vary"], "Cookie")
1134
1135 @override_settings(
1136 SESSION_COOKIE_DOMAIN=".example.local", SESSION_COOKIE_PATH="/example/"
1137 )
1138 def test_session_delete_on_end_with_custom_domain_and_path(self):
1139 def response_ending_session(request):
1140 request.session.flush()
1141 return HttpResponse("Session test")
1142
1143 request = self.request_factory.get("/")
1144 middleware = SessionMiddleware(response_ending_session)
1145
1146 # Before deleting, there has to be an existing cookie
1147 request.COOKIES[settings.SESSION_COOKIE_NAME] = "abc"
1148
1149 # Handle the response through the middleware
1150 response = middleware(request)
1151
1152 # The cookie was deleted, not recreated.
1153 # A deleted cookie header with a custom domain and path looks like:
1154 # Set-Cookie: sessionid=; Domain=.example.local;
1155 # expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0;
1156 # Path=/example/
1157 self.assertEqual(
1158 'Set-Cookie: {}=""; Domain=.example.local; expires=Thu, '
1159 "01 Jan 1970 00:00:00 GMT; Max-Age=0; Path=/example/; SameSite={}".format(
1160 settings.SESSION_COOKIE_NAME,
1161 settings.SESSION_COOKIE_SAMESITE,
1162 ),
1163 str(response.cookies[settings.SESSION_COOKIE_NAME]),
1164 )
1165 self.assertEqual(response.headers["Vary"], "Cookie")
1166
1167 def test_flush_empty_without_session_cookie_doesnt_set_cookie(self):
1168 def response_ending_session(request):
1169 request.session.flush()
1170 return HttpResponse("Session test")
1171
1172 request = self.request_factory.get("/")
1173 middleware = SessionMiddleware(response_ending_session)
1174
1175 # Handle the response through the middleware
1176 response = middleware(request)
1177
1178 # A cookie should not be set.
1179 self.assertEqual(response.cookies, {})
1180 # The session is accessed so "Vary: Cookie" should be set.
1181 self.assertEqual(response.headers["Vary"], "Cookie")
1182
1183 @override_settings(SESSION_SAVE_EVERY_REQUEST=True)
1184 def test_save_every_request_with_non_empty_session_renews_session_cookie(self):
1185 request = self.request_factory.get("/")
1186 middleware = SessionMiddleware(self.get_response_touching_session)
1187
1188 # Make sure the request has a session.
1189 middleware(request)
1190
1191 # A cookie should be set.
1192 self.assertIs(request.session.is_empty(), False)
1193 self.assertEqual(request.session["hello"], "world")
1194
1195 request.COOKIES[settings.SESSION_COOKIE_NAME] = request.session.session_key
1196
1197 def simple_view(request):
1198 return HttpResponse("Session test")
1199
1200 middleware = SessionMiddleware(simple_view)
1201 response = middleware(request)
1202
1203 # A cookie should be set because SESSION_SAVE_EVERY_REQUEST=True,
1204 # even though the session wasn't touched.
1205 self.assertIn(settings.SESSION_COOKIE_NAME, response.cookies)
1206 # There's a session, so also Vary on it.
1207 self.assertEqual(response.headers["Vary"], "Cookie")
1208
1209 def test_empty_session_saved(self):
1210 """
1211 If a session is emptied of data but still has a key, it should still
1212 be updated.
1213 """
1214
1215 def response_set_session(request):
1216 # Set a session key and some data.
1217 request.session["foo"] = "bar"
1218 return HttpResponse("Session test")
1219
1220 request = self.request_factory.get("/")
1221 middleware = SessionMiddleware(response_set_session)
1222
1223 # Handle the response through the middleware.
1224 response = middleware(request)
1225 self.assertEqual(tuple(request.session.items()), (("foo", "bar"),))
1226 # A cookie should be set, along with Vary: Cookie.
1227 self.assertIn(
1228 "Set-Cookie: sessionid=%s" % request.session.session_key,
1229 str(response.cookies),
1230 )
1231 self.assertEqual(response.headers["Vary"], "Cookie")
1232
1233 # Empty the session data.
1234 del request.session["foo"]
1235 # Handle the response through the middleware.
1236 response = HttpResponse("Session test")
1237 response = middleware.process_response(request, response)
1238 self.assertEqual(dict(request.session.values()), {})
1239 session = Session.objects.get(session_key=request.session.session_key)
1240 self.assertEqual(session.get_decoded(), {})
1241 # While the session is empty, it hasn't been flushed so a cookie should
1242 # still be set, along with Vary: Cookie.
1243 self.assertGreater(len(request.session.session_key), 8)
1244 self.assertIn(
1245 "Set-Cookie: sessionid=%s" % request.session.session_key,
1246 str(response.cookies),
1247 )
1248 self.assertEqual(response.headers["Vary"], "Cookie")
1249
1250
1251 class CookieSessionTests(SessionTestsMixin, SimpleTestCase):
1252 backend = CookieSession
1253
1254 def test_save(self):
1255 """
1256 This test tested exists() in the other session backends, but that
1257 doesn't make sense for us.
1258 """
1259 pass
1260
1261 async def test_save_async(self):
1262 pass
1263
1264 def test_cycle(self):
1265 """
1266 This test tested cycle_key() which would create a new session
1267 key for the same session data. But we can't invalidate previously
1268 signed cookies (other than letting them expire naturally) so
1269 testing for this behavior is meaningless.
1270 """
1271 pass
1272
1273 async def test_cycle_async(self):
1274 pass
1275
1276 @unittest.expectedFailure
1277 def test_actual_expiry(self):
1278 # The cookie backend doesn't handle non-default expiry dates, see #19201
1279 super().test_actual_expiry()
1280
1281 async def test_actual_expiry_async(self):
1282 pass
1283
1284 def test_unpickling_exception(self):
1285 # signed_cookies backend should handle unpickle exceptions gracefully
1286 # by creating a new session
1287 self.assertEqual(self.session.serializer, JSONSerializer)
1288 self.session.save()
1289 with mock.patch("django.core.signing.loads", side_effect=ValueError):
1290 self.session.load()
1291
1292 @unittest.skip(
1293 "Cookie backend doesn't have an external store to create records in."
1294 )
1295 def test_session_load_does_not_create_record(self):
1296 pass
1297
1298 @unittest.skip(
1299 "Cookie backend doesn't have an external store to create records in."
1300 )
1301 async def test_session_load_does_not_create_record_async(self):
1302 pass
1303
1304 @unittest.skip(
1305 "CookieSession is stored in the client and there is no way to query it."
1306 )
1307 def test_session_save_does_not_resurrect_session_logged_out_in_other_context(self):
1308 pass
1309
1310 @unittest.skip(
1311 "CookieSession is stored in the client and there is no way to query it."
1312 )
1313 async def test_session_asave_does_not_resurrect_session_logged_out_in_other_context(
1314 self,
1315 ):
1316 pass
1317
1318
1319 class ClearSessionsCommandTests(SimpleTestCase):
1320 def test_clearsessions_unsupported(self):
1321 msg = (
1322 "Session engine 'sessions_tests.no_clear_expired' doesn't "
1323 "support clearing expired sessions."
1324 )
1325 with self.settings(SESSION_ENGINE="sessions_tests.no_clear_expired"):
1326 with self.assertRaisesMessage(management.CommandError, msg):
1327 management.call_command("clearsessions")
1328
1329
1330 class SessionBaseTests(SimpleTestCase):
1331 not_implemented_msg = "subclasses of SessionBase must provide %s() method"
1332
1333 def setUp(self):
1334 self.session = SessionBase()
1335
1336 def test_create(self):
1337 msg = self.not_implemented_msg % "a create"
1338 with self.assertRaisesMessage(NotImplementedError, msg):
1339 self.session.create()
1340
1341 async def test_acreate(self):
1342 msg = self.not_implemented_msg % "a create"
1343 with self.assertRaisesMessage(NotImplementedError, msg):
1344 await self.session.acreate()
1345
1346 def test_delete(self):
1347 msg = self.not_implemented_msg % "a delete"
1348 with self.assertRaisesMessage(NotImplementedError, msg):
1349 self.session.delete()
1350
1351 async def test_adelete(self):
1352 msg = self.not_implemented_msg % "a delete"
1353 with self.assertRaisesMessage(NotImplementedError, msg):
1354 await self.session.adelete()
1355
1356 def test_exists(self):
1357 msg = self.not_implemented_msg % "an exists"
1358 with self.assertRaisesMessage(NotImplementedError, msg):
1359 self.session.exists(None)
1360
1361 async def test_aexists(self):
1362 msg = self.not_implemented_msg % "an exists"
1363 with self.assertRaisesMessage(NotImplementedError, msg):
1364 await self.session.aexists(None)
1365
1366 def test_load(self):
1367 msg = self.not_implemented_msg % "a load"
1368 with self.assertRaisesMessage(NotImplementedError, msg):
1369 self.session.load()
1370
1371 async def test_aload(self):
1372 msg = self.not_implemented_msg % "a load"
1373 with self.assertRaisesMessage(NotImplementedError, msg):
1374 await self.session.aload()
1375
1376 def test_save(self):
1377 msg = self.not_implemented_msg % "a save"
1378 with self.assertRaisesMessage(NotImplementedError, msg):
1379 self.session.save()
1380
1381 async def test_asave(self):
1382 msg = self.not_implemented_msg % "a save"
1383 with self.assertRaisesMessage(NotImplementedError, msg):
1384 await self.session.asave()
1385
1386 def test_test_cookie(self):
1387 self.assertIs(self.session.has_key(self.session.TEST_COOKIE_NAME), False)
1388 self.session.set_test_cookie()
1389 self.assertIs(self.session.test_cookie_worked(), True)
1390 self.session.delete_test_cookie()
1391 self.assertIs(self.session.has_key(self.session.TEST_COOKIE_NAME), False)
1392
1393 async def test_atest_cookie(self):
1394 self.assertIs(await self.session.ahas_key(self.session.TEST_COOKIE_NAME), False)
1395 await self.session.aset_test_cookie()
1396 self.assertIs(await self.session.atest_cookie_worked(), True)
1397 await self.session.adelete_test_cookie()
1398 self.assertIs(await self.session.ahas_key(self.session.TEST_COOKIE_NAME), False)
1399
1400 def test_is_empty(self):
1401 self.assertIs(self.session.is_empty(), True)