Debian Codegraph @

tests/cache/tests.py

raw
1 # Unit tests for cache framework
2 # Uses whatever cache backend is set in the test settings file.
3 import copy
4 import io
5 import os
6 import pickle
7 import shutil
8 import sys
9 import tempfile
10 import threading
11 import time
12 import unittest
13 from functools import wraps
14 from pathlib import Path
15 from unittest import mock, skipIf
16
17 from django.conf import settings
18 from django.core import management, signals
19 from django.core.cache import (
20 DEFAULT_CACHE_ALIAS,
21 CacheHandler,
22 CacheKeyWarning,
23 InvalidCacheKey,
24 cache,
25 caches,
26 )
27 from django.core.cache.backends.base import InvalidCacheBackendError
28 from django.core.cache.backends.redis import RedisCacheClient
29 from django.core.cache.utils import make_template_fragment_key
30 from django.db import close_old_connections, connection, connections
31 from django.db.backends.utils import CursorWrapper
32 from django.http import (
33 HttpRequest,
34 HttpResponse,
35 HttpResponseNotModified,
36 StreamingHttpResponse,
37 )
38 from django.middleware.cache import (
39 CacheMiddleware,
40 FetchFromCacheMiddleware,
41 UpdateCacheMiddleware,
42 )
43 from django.middleware.csrf import CsrfViewMiddleware
44 from django.template import engines
45 from django.template.context_processors import csrf
46 from django.template.response import TemplateResponse
47 from django.test import (
48 RequestFactory,
49 SimpleTestCase,
50 TestCase,
51 TransactionTestCase,
52 override_settings,
53 )
54 from django.test.signals import setting_changed
55 from django.test.utils import CaptureQueriesContext
56 from django.utils import timezone, translation
57 from django.utils.cache import (
58 cc_delim_re,
59 get_cache_key,
60 has_vary_header,
61 learn_cache_key,
62 patch_cache_control,
63 patch_vary_headers,
64 )
65 from django.views.decorators.cache import cache_control, cache_page
66
67 from .models import Poll, expensive_calculation
68
69
70 # functions/classes for complex data type tests
71 def f():
72 return 42
73
74
75 class C:
76 def m(n):
77 return 24
78
79
80 class Unpicklable:
81 def __getstate__(self):
82 raise pickle.PickleError()
83
84
85 def empty_response(request):
86 return HttpResponse()
87
88
89 KEY_ERRORS_WITH_MEMCACHED_MSG = (
90 "Cache key contains characters that will cause errors if used with memcached: %r"
91 )
92
93
94 def retry(retries=3, delay=1):
95 def decorator(func):
96 @wraps(func)
97 def wrapper(*args, **kwargs):
98 attempts = 0
99 while attempts < retries:
100 try:
101 return func(*args, **kwargs)
102 except AssertionError:
103 attempts += 1
104 if attempts >= retries:
105 raise
106 time.sleep(delay)
107
108 return wrapper
109
110 return decorator
111
112
113 @override_settings(
114 CACHES={
115 "default": {
116 "BACKEND": "django.core.cache.backends.dummy.DummyCache",
117 }
118 }
119 )
120 class DummyCacheTests(SimpleTestCase):
121 # The Dummy cache backend doesn't really behave like a test backend,
122 # so it has its own test case.
123
124 def test_simple(self):
125 "Dummy cache backend ignores cache set calls"
126 cache.set("key", "value")
127 self.assertIsNone(cache.get("key"))
128
129 def test_add(self):
130 "Add doesn't do anything in dummy cache backend"
131 self.assertIs(cache.add("addkey1", "value"), True)
132 self.assertIs(cache.add("addkey1", "newvalue"), True)
133 self.assertIsNone(cache.get("addkey1"))
134
135 def test_non_existent(self):
136 "Nonexistent keys aren't found in the dummy cache backend"
137 self.assertIsNone(cache.get("does_not_exist"))
138 self.assertEqual(cache.get("does_not_exist", "bang!"), "bang!")
139
140 def test_get_many(self):
141 "get_many returns nothing for the dummy cache backend"
142 cache.set_many({"a": "a", "b": "b", "c": "c", "d": "d"})
143 self.assertEqual(cache.get_many(["a", "c", "d"]), {})
144 self.assertEqual(cache.get_many(["a", "b", "e"]), {})
145
146 def test_get_many_invalid_key(self):
147 msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ":1:key with spaces"
148 with self.assertWarnsMessage(CacheKeyWarning, msg):
149 cache.get_many(["key with spaces"])
150
151 def test_delete(self):
152 "Cache deletion is transparently ignored on the dummy cache backend"
153 cache.set_many({"key1": "spam", "key2": "eggs"})
154 self.assertIsNone(cache.get("key1"))
155 self.assertIs(cache.delete("key1"), False)
156 self.assertIsNone(cache.get("key1"))
157 self.assertIsNone(cache.get("key2"))
158
159 def test_has_key(self):
160 "The has_key method doesn't ever return True for the dummy cache backend"
161 cache.set("hello1", "goodbye1")
162 self.assertIs(cache.has_key("hello1"), False)
163 self.assertIs(cache.has_key("goodbye1"), False)
164
165 def test_in(self):
166 "The in operator doesn't ever return True for the dummy cache backend"
167 cache.set("hello2", "goodbye2")
168 self.assertNotIn("hello2", cache)
169 self.assertNotIn("goodbye2", cache)
170
171 def test_incr(self):
172 "Dummy cache values can't be incremented"
173 cache.set("answer", 42)
174 with self.assertRaises(ValueError):
175 cache.incr("answer")
176 with self.assertRaises(ValueError):
177 cache.incr("does_not_exist")
178 with self.assertRaises(ValueError):
179 cache.incr("does_not_exist", -1)
180
181 def test_decr(self):
182 "Dummy cache values can't be decremented"
183 cache.set("answer", 42)
184 with self.assertRaises(ValueError):
185 cache.decr("answer")
186 with self.assertRaises(ValueError):
187 cache.decr("does_not_exist")
188 with self.assertRaises(ValueError):
189 cache.decr("does_not_exist", -1)
190
191 def test_touch(self):
192 """Dummy cache can't do touch()."""
193 self.assertIs(cache.touch("whatever"), False)
194
195 def test_data_types(self):
196 "All data types are ignored equally by the dummy cache"
197 tests = {
198 "string": "this is a string",
199 "int": 42,
200 "bool": True,
201 "list": [1, 2, 3, 4],
202 "tuple": (1, 2, 3, 4),
203 "dict": {"A": 1, "B": 2},
204 "function": f,
205 "class": C,
206 }
207 for key, value in tests.items():
208 with self.subTest(key=key):
209 cache.set(key, value)
210 self.assertIsNone(cache.get(key))
211
212 def test_expiration(self):
213 "Expiration has no effect on the dummy cache"
214 cache.set("expire1", "very quickly", 1)
215 cache.set("expire2", "very quickly", 1)
216 cache.set("expire3", "very quickly", 1)
217
218 time.sleep(2)
219 self.assertIsNone(cache.get("expire1"))
220
221 self.assertIs(cache.add("expire2", "newvalue"), True)
222 self.assertIsNone(cache.get("expire2"))
223 self.assertIs(cache.has_key("expire3"), False)
224
225 def test_unicode(self):
226 "Unicode values are ignored by the dummy cache"
227 stuff = {
228 "ascii": "ascii_value",
229 "unicode_ascii": "Iรฑtรซrnรขtiรดnร lizรฆtiรธn1",
230 "Iรฑtรซrnรขtiรดnร lizรฆtiรธn": "Iรฑtรซrnรขtiรดnร lizรฆtiรธn2",
231 "ascii2": {"x": 1},
232 }
233 for key, value in stuff.items():
234 with self.subTest(key=key):
235 cache.set(key, value)
236 self.assertIsNone(cache.get(key))
237
238 def test_set_many(self):
239 "set_many does nothing for the dummy cache backend"
240 self.assertEqual(cache.set_many({"a": 1, "b": 2}), [])
241 self.assertEqual(cache.set_many({"a": 1, "b": 2}, timeout=2, version="1"), [])
242
243 def test_set_many_invalid_key(self):
244 msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ":1:key with spaces"
245 with self.assertWarnsMessage(CacheKeyWarning, msg):
246 cache.set_many({"key with spaces": "foo"})
247
248 def test_delete_many(self):
249 "delete_many does nothing for the dummy cache backend"
250 cache.delete_many(["a", "b"])
251
252 def test_delete_many_invalid_key(self):
253 msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ":1:key with spaces"
254 with self.assertWarnsMessage(CacheKeyWarning, msg):
255 cache.delete_many(["key with spaces"])
256
257 def test_clear(self):
258 "clear does nothing for the dummy cache backend"
259 cache.clear()
260
261 def test_incr_version(self):
262 "Dummy cache versions can't be incremented"
263 cache.set("answer", 42)
264 with self.assertRaises(ValueError):
265 cache.incr_version("answer")
266 with self.assertRaises(ValueError):
267 cache.incr_version("does_not_exist")
268
269 def test_decr_version(self):
270 "Dummy cache versions can't be decremented"
271 cache.set("answer", 42)
272 with self.assertRaises(ValueError):
273 cache.decr_version("answer")
274 with self.assertRaises(ValueError):
275 cache.decr_version("does_not_exist")
276
277 def test_get_or_set(self):
278 self.assertEqual(cache.get_or_set("mykey", "default"), "default")
279 self.assertIsNone(cache.get_or_set("mykey", None))
280
281 def test_get_or_set_callable(self):
282 def my_callable():
283 return "default"
284
285 self.assertEqual(cache.get_or_set("mykey", my_callable), "default")
286 self.assertEqual(cache.get_or_set("mykey", my_callable()), "default")
287
288
289 def custom_key_func(key, key_prefix, version):
290 "A customized cache key function"
291 return "CUSTOM-" + "-".join([key_prefix, str(version), key])
292
293
294 _caches_setting_base = {
295 "default": {},
296 "prefix": {"KEY_PREFIX": "cacheprefix{}".format(os.getpid())},
297 "v2": {"VERSION": 2},
298 "custom_key": {"KEY_FUNCTION": custom_key_func},
299 "custom_key2": {"KEY_FUNCTION": "cache.tests.custom_key_func"},
300 "cull": {"OPTIONS": {"MAX_ENTRIES": 30}},
301 "zero_cull": {"OPTIONS": {"CULL_FREQUENCY": 0, "MAX_ENTRIES": 30}},
302 }
303
304
305 def caches_setting_for_tests(base=None, exclude=None, **params):
306 # `base` is used to pull in the memcached config from the original settings,
307 # `exclude` is a set of cache names denoting which `_caches_setting_base` keys
308 # should be omitted.
309 # `params` are test specific overrides and `_caches_settings_base` is the
310 # base config for the tests.
311 # This results in the following search order:
312 # params -> _caches_setting_base -> base
313 base = base or {}
314 exclude = exclude or set()
315 setting = {k: base.copy() for k in _caches_setting_base if k not in exclude}
316 for key, cache_params in setting.items():
317 cache_params.update(_caches_setting_base[key])
318 cache_params.update(params)
319 return setting
320
321
322 class BaseCacheTests:
323 # A common set of tests to apply to all cache backends
324 factory = RequestFactory()
325
326 # Some clients raise custom exceptions when .incr() or .decr() are called
327 # with a non-integer value.
328 incr_decr_type_error = TypeError
329
330 def tearDown(self):
331 cache.clear()
332
333 def test_simple(self):
334 # Simple cache set/get works
335 cache.set("key", "value")
336 self.assertEqual(cache.get("key"), "value")
337
338 def test_default_used_when_none_is_set(self):
339 """If None is cached, get() returns it instead of the default."""
340 cache.set("key_default_none", None)
341 self.assertIsNone(cache.get("key_default_none", default="default"))
342
343 def test_add(self):
344 # A key can be added to a cache
345 self.assertIs(cache.add("addkey1", "value"), True)
346 self.assertIs(cache.add("addkey1", "newvalue"), False)
347 self.assertEqual(cache.get("addkey1"), "value")
348
349 def test_prefix(self):
350 # Test for same cache key conflicts between shared backend
351 cache.set("somekey", "value")
352
353 # should not be set in the prefixed cache
354 self.assertIs(caches["prefix"].has_key("somekey"), False)
355
356 caches["prefix"].set("somekey", "value2")
357
358 self.assertEqual(cache.get("somekey"), "value")
359 self.assertEqual(caches["prefix"].get("somekey"), "value2")
360
361 def test_non_existent(self):
362 """Nonexistent cache keys return as None/default."""
363 self.assertIsNone(cache.get("does_not_exist"))
364 self.assertEqual(cache.get("does_not_exist", "bang!"), "bang!")
365
366 def test_get_many(self):
367 # Multiple cache keys can be returned using get_many
368 cache.set_many({"a": "a", "b": "b", "c": "c", "d": "d"})
369 self.assertEqual(
370 cache.get_many(["a", "c", "d"]), {"a": "a", "c": "c", "d": "d"}
371 )
372 self.assertEqual(cache.get_many(["a", "b", "e"]), {"a": "a", "b": "b"})
373 self.assertEqual(cache.get_many(iter(["a", "b", "e"])), {"a": "a", "b": "b"})
374 cache.set_many({"x": None, "y": 1})
375 self.assertEqual(cache.get_many(["x", "y"]), {"x": None, "y": 1})
376
377 def test_delete(self):
378 # Cache keys can be deleted
379 cache.set_many({"key1": "spam", "key2": "eggs"})
380 self.assertEqual(cache.get("key1"), "spam")
381 self.assertIs(cache.delete("key1"), True)
382 self.assertIsNone(cache.get("key1"))
383 self.assertEqual(cache.get("key2"), "eggs")
384
385 def test_delete_nonexistent(self):
386 self.assertIs(cache.delete("nonexistent_key"), False)
387
388 def test_has_key(self):
389 # The cache can be inspected for cache keys
390 cache.set("hello1", "goodbye1")
391 self.assertIs(cache.has_key("hello1"), True)
392 self.assertIs(cache.has_key("goodbye1"), False)
393 cache.set("no_expiry", "here", None)
394 self.assertIs(cache.has_key("no_expiry"), True)
395 cache.set("null", None)
396 self.assertIs(cache.has_key("null"), True)
397
398 def test_in(self):
399 # The in operator can be used to inspect cache contents
400 cache.set("hello2", "goodbye2")
401 self.assertIn("hello2", cache)
402 self.assertNotIn("goodbye2", cache)
403 cache.set("null", None)
404 self.assertIn("null", cache)
405
406 def test_incr(self):
407 # Cache values can be incremented
408 cache.set("answer", 41)
409 self.assertEqual(cache.incr("answer"), 42)
410 self.assertEqual(cache.get("answer"), 42)
411 self.assertEqual(cache.incr("answer", 10), 52)
412 self.assertEqual(cache.get("answer"), 52)
413 self.assertEqual(cache.incr("answer", -10), 42)
414 with self.assertRaises(ValueError):
415 cache.incr("does_not_exist")
416 with self.assertRaises(ValueError):
417 cache.incr("does_not_exist", -1)
418 cache.set("null", None)
419 with self.assertRaises(self.incr_decr_type_error):
420 cache.incr("null")
421
422 def test_decr(self):
423 # Cache values can be decremented
424 cache.set("answer", 43)
425 self.assertEqual(cache.decr("answer"), 42)
426 self.assertEqual(cache.get("answer"), 42)
427 self.assertEqual(cache.decr("answer", 10), 32)
428 self.assertEqual(cache.get("answer"), 32)
429 self.assertEqual(cache.decr("answer", -10), 42)
430 with self.assertRaises(ValueError):
431 cache.decr("does_not_exist")
432 with self.assertRaises(ValueError):
433 cache.incr("does_not_exist", -1)
434 cache.set("null", None)
435 with self.assertRaises(self.incr_decr_type_error):
436 cache.decr("null")
437
438 def test_close(self):
439 self.assertTrue(hasattr(cache, "close"))
440 cache.close()
441
442 def test_data_types(self):
443 # Many different data types can be cached
444 tests = {
445 "string": "this is a string",
446 "int": 42,
447 "bool": True,
448 "list": [1, 2, 3, 4],
449 "tuple": (1, 2, 3, 4),
450 "dict": {"A": 1, "B": 2},
451 "function": f,
452 "class": C,
453 }
454 for key, value in tests.items():
455 with self.subTest(key=key):
456 cache.set(key, value)
457 self.assertEqual(cache.get(key), value)
458
459 def test_cache_read_for_model_instance(self):
460 # Don't want fields with callable as default to be called on cache read
461 expensive_calculation.num_runs = 0
462 Poll.objects.all().delete()
463 my_poll = Poll.objects.create(question="Well?")
464 self.assertEqual(Poll.objects.count(), 1)
465 pub_date = my_poll.pub_date
466 cache.set("question", my_poll)
467 cached_poll = cache.get("question")
468 self.assertEqual(cached_poll.pub_date, pub_date)
469 # We only want the default expensive calculation run once
470 self.assertEqual(expensive_calculation.num_runs, 1)
471
472 def test_cache_write_for_model_instance_with_deferred(self):
473 # Don't want fields with callable as default to be called on cache write
474 expensive_calculation.num_runs = 0
475 Poll.objects.all().delete()
476 Poll.objects.create(question="What?")
477 self.assertEqual(expensive_calculation.num_runs, 1)
478 defer_qs = Poll.objects.defer("question")
479 self.assertEqual(defer_qs.count(), 1)
480 self.assertEqual(expensive_calculation.num_runs, 1)
481 cache.set("deferred_queryset", defer_qs)
482 # cache set should not re-evaluate default functions
483 self.assertEqual(expensive_calculation.num_runs, 1)
484
485 def test_cache_read_for_model_instance_with_deferred(self):
486 # Don't want fields with callable as default to be called on cache read
487 expensive_calculation.num_runs = 0
488 Poll.objects.all().delete()
489 Poll.objects.create(question="What?")
490 self.assertEqual(expensive_calculation.num_runs, 1)
491 defer_qs = Poll.objects.defer("question")
492 self.assertEqual(defer_qs.count(), 1)
493 cache.set("deferred_queryset", defer_qs)
494 self.assertEqual(expensive_calculation.num_runs, 1)
495 runs_before_cache_read = expensive_calculation.num_runs
496 cache.get("deferred_queryset")
497 # We only want the default expensive calculation run on creation and set
498 self.assertEqual(expensive_calculation.num_runs, runs_before_cache_read)
499
500 def test_expiration(self):
501 # Cache values can be set to expire
502 cache.set("expire1", "very quickly", 1)
503 cache.set("expire2", "very quickly", 1)
504 cache.set("expire3", "very quickly", 1)
505
506 time.sleep(2)
507 self.assertIsNone(cache.get("expire1"))
508
509 self.assertIs(cache.add("expire2", "newvalue"), True)
510 self.assertEqual(cache.get("expire2"), "newvalue")
511 self.assertIs(cache.has_key("expire3"), False)
512
513 @retry()
514 def test_touch(self):
515 # cache.touch() updates the timeout.
516 cache.set("expire1", "very quickly", timeout=1)
517 self.assertIs(cache.touch("expire1", timeout=4), True)
518 time.sleep(2)
519 self.assertIs(cache.has_key("expire1"), True)
520 time.sleep(3)
521 self.assertIs(cache.has_key("expire1"), False)
522 # cache.touch() works without the timeout argument.
523 cache.set("expire1", "very quickly", timeout=1)
524 self.assertIs(cache.touch("expire1"), True)
525 time.sleep(2)
526 self.assertIs(cache.has_key("expire1"), True)
527
528 self.assertIs(cache.touch("nonexistent"), False)
529
530 def test_unicode(self):
531 # Unicode values can be cached
532 stuff = {
533 "ascii": "ascii_value",
534 "unicode_ascii": "Iรฑtรซrnรขtiรดnร lizรฆtiรธn1",
535 "Iรฑtรซrnรขtiรดnร lizรฆtiรธn": "Iรฑtรซrnรขtiรดnร lizรฆtiรธn2",
536 "ascii2": {"x": 1},
537 }
538 # Test `set`
539 for key, value in stuff.items():
540 with self.subTest(key=key):
541 cache.set(key, value)
542 self.assertEqual(cache.get(key), value)
543
544 # Test `add`
545 for key, value in stuff.items():
546 with self.subTest(key=key):
547 self.assertIs(cache.delete(key), True)
548 self.assertIs(cache.add(key, value), True)
549 self.assertEqual(cache.get(key), value)
550
551 # Test `set_many`
552 for key, value in stuff.items():
553 self.assertIs(cache.delete(key), True)
554 cache.set_many(stuff)
555 for key, value in stuff.items():
556 with self.subTest(key=key):
557 self.assertEqual(cache.get(key), value)
558
559 def test_binary_string(self):
560 # Binary strings should be cacheable
561 from zlib import compress, decompress
562
563 value = "value_to_be_compressed"
564 compressed_value = compress(value.encode())
565
566 # Test set
567 cache.set("binary1", compressed_value)
568 compressed_result = cache.get("binary1")
569 self.assertEqual(compressed_value, compressed_result)
570 self.assertEqual(value, decompress(compressed_result).decode())
571
572 # Test add
573 self.assertIs(cache.add("binary1-add", compressed_value), True)
574 compressed_result = cache.get("binary1-add")
575 self.assertEqual(compressed_value, compressed_result)
576 self.assertEqual(value, decompress(compressed_result).decode())
577
578 # Test set_many
579 cache.set_many({"binary1-set_many": compressed_value})
580 compressed_result = cache.get("binary1-set_many")
581 self.assertEqual(compressed_value, compressed_result)
582 self.assertEqual(value, decompress(compressed_result).decode())
583
584 def test_set_many(self):
585 # Multiple keys can be set using set_many
586 cache.set_many({"key1": "spam", "key2": "eggs"})
587 self.assertEqual(cache.get("key1"), "spam")
588 self.assertEqual(cache.get("key2"), "eggs")
589
590 def test_set_many_returns_empty_list_on_success(self):
591 """set_many() returns an empty list when all keys are inserted."""
592 failing_keys = cache.set_many({"key1": "spam", "key2": "eggs"})
593 self.assertEqual(failing_keys, [])
594
595 def test_set_many_expiration(self):
596 # set_many takes a second ``timeout`` parameter
597 cache.set_many({"key1": "spam", "key2": "eggs"}, 1)
598 time.sleep(2)
599 self.assertIsNone(cache.get("key1"))
600 self.assertIsNone(cache.get("key2"))
601
602 def test_set_many_empty_data(self):
603 self.assertEqual(cache.set_many({}), [])
604
605 def test_delete_many(self):
606 # Multiple keys can be deleted using delete_many
607 cache.set_many({"key1": "spam", "key2": "eggs", "key3": "ham"})
608 cache.delete_many(["key1", "key2"])
609 self.assertIsNone(cache.get("key1"))
610 self.assertIsNone(cache.get("key2"))
611 self.assertEqual(cache.get("key3"), "ham")
612
613 def test_delete_many_no_keys(self):
614 self.assertIsNone(cache.delete_many([]))
615
616 def test_clear(self):
617 # The cache can be emptied using clear
618 cache.set_many({"key1": "spam", "key2": "eggs"})
619 cache.clear()
620 self.assertIsNone(cache.get("key1"))
621 self.assertIsNone(cache.get("key2"))
622
623 def test_long_timeout(self):
624 """
625 Follow memcached's convention where a timeout greater than 30 days is
626 treated as an absolute expiration timestamp instead of a relative
627 offset (#12399).
628 """
629 cache.set("key1", "eggs", 60 * 60 * 24 * 30 + 1) # 30 days + 1 second
630 self.assertEqual(cache.get("key1"), "eggs")
631
632 self.assertIs(cache.add("key2", "ham", 60 * 60 * 24 * 30 + 1), True)
633 self.assertEqual(cache.get("key2"), "ham")
634
635 cache.set_many(
636 {"key3": "sausage", "key4": "lobster bisque"}, 60 * 60 * 24 * 30 + 1
637 )
638 self.assertEqual(cache.get("key3"), "sausage")
639 self.assertEqual(cache.get("key4"), "lobster bisque")
640
641 @retry()
642 def test_forever_timeout(self):
643 """
644 Passing in None into timeout results in a value that is cached forever
645 """
646 cache.set("key1", "eggs", None)
647 self.assertEqual(cache.get("key1"), "eggs")
648
649 self.assertIs(cache.add("key2", "ham", None), True)
650 self.assertEqual(cache.get("key2"), "ham")
651 self.assertIs(cache.add("key1", "new eggs", None), False)
652 self.assertEqual(cache.get("key1"), "eggs")
653
654 cache.set_many({"key3": "sausage", "key4": "lobster bisque"}, None)
655 self.assertEqual(cache.get("key3"), "sausage")
656 self.assertEqual(cache.get("key4"), "lobster bisque")
657
658 cache.set("key5", "belgian fries", timeout=1)
659 self.assertIs(cache.touch("key5", timeout=None), True)
660 time.sleep(2)
661 self.assertEqual(cache.get("key5"), "belgian fries")
662
663 def test_zero_timeout(self):
664 """
665 Passing in zero into timeout results in a value that is not cached
666 """
667 cache.set("key1", "eggs", 0)
668 self.assertIsNone(cache.get("key1"))
669
670 self.assertIs(cache.add("key2", "ham", 0), True)
671 self.assertIsNone(cache.get("key2"))
672
673 cache.set_many({"key3": "sausage", "key4": "lobster bisque"}, 0)
674 self.assertIsNone(cache.get("key3"))
675 self.assertIsNone(cache.get("key4"))
676
677 cache.set("key5", "belgian fries", timeout=5)
678 self.assertIs(cache.touch("key5", timeout=0), True)
679 self.assertIsNone(cache.get("key5"))
680
681 def test_float_timeout(self):
682 # Make sure a timeout given as a float doesn't crash anything.
683 cache.set("key1", "spam", 100.2)
684 self.assertEqual(cache.get("key1"), "spam")
685
686 def _perform_cull_test(self, cull_cache_name, initial_count, final_count):
687 try:
688 cull_cache = caches[cull_cache_name]
689 except InvalidCacheBackendError:
690 self.skipTest("Culling isn't implemented.")
691
692 # Create initial cache key entries. This will overflow the cache,
693 # causing a cull.
694 for i in range(1, initial_count):
695 cull_cache.set("cull%d" % i, "value", 1000)
696 count = 0
697 # Count how many keys are left in the cache.
698 for i in range(1, initial_count):
699 if cull_cache.has_key("cull%d" % i):
700 count += 1
701 self.assertEqual(count, final_count)
702
703 def test_cull(self):
704 self._perform_cull_test("cull", 50, 29)
705
706 def test_zero_cull(self):
707 self._perform_cull_test("zero_cull", 50, 19)
708
709 def test_cull_delete_when_store_empty(self):
710 try:
711 cull_cache = caches["cull"]
712 except InvalidCacheBackendError:
713 self.skipTest("Culling isn't implemented.")
714 old_max_entries = cull_cache._max_entries
715 # Force _cull to delete on first cached record.
716 cull_cache._max_entries = -1
717 try:
718 cull_cache.set("force_cull_delete", "value", 1000)
719 self.assertIs(cull_cache.has_key("force_cull_delete"), True)
720 finally:
721 cull_cache._max_entries = old_max_entries
722
723 def _perform_invalid_key_test(self, key, expected_warning, key_func=None):
724 """
725 All the builtin backends should warn (except memcached that should
726 error) on keys that would be refused by memcached. This encourages
727 portable caching code without making it too difficult to use production
728 backends with more liberal key rules. Refs #6447.
729 """
730
731 # mimic custom ``make_key`` method being defined since the default will
732 # never show the below warnings
733 def func(key, *args):
734 return key
735
736 old_func = cache.key_func
737 cache.key_func = key_func or func
738
739 tests = [
740 ("add", [key, 1]),
741 ("get", [key]),
742 ("set", [key, 1]),
743 ("incr", [key]),
744 ("decr", [key]),
745 ("touch", [key]),
746 ("delete", [key]),
747 ("get_many", [[key, "b"]]),
748 ("set_many", [{key: 1, "b": 2}]),
749 ("delete_many", [[key, "b"]]),
750 ]
751 try:
752 for operation, args in tests:
753 with self.subTest(operation=operation):
754 with self.assertWarns(CacheKeyWarning) as cm:
755 getattr(cache, operation)(*args)
756 self.assertEqual(str(cm.warning), expected_warning)
757 finally:
758 cache.key_func = old_func
759
760 def test_invalid_key_characters(self):
761 # memcached doesn't allow whitespace or control characters in keys.
762 key = "key with spaces and ๆธ…"
763 self._perform_invalid_key_test(key, KEY_ERRORS_WITH_MEMCACHED_MSG % key)
764
765 def test_invalid_key_length(self):
766 # memcached limits key length to 250.
767 key = ("a" * 250) + "ๆธ…"
768 expected_warning = (
769 "Cache key will cause errors if used with memcached: "
770 "%r (longer than %s)" % (key, 250)
771 )
772 self._perform_invalid_key_test(key, expected_warning)
773
774 def test_invalid_with_version_key_length(self):
775 # Custom make_key() that adds a version to the key and exceeds the
776 # limit.
777 def key_func(key, *args):
778 return key + ":1"
779
780 key = "a" * 249
781 expected_warning = (
782 "Cache key will cause errors if used with memcached: "
783 "%r (longer than %s)" % (key_func(key), 250)
784 )
785 self._perform_invalid_key_test(key, expected_warning, key_func=key_func)
786
787 def test_cache_versioning_get_set(self):
788 # set, using default version = 1
789 cache.set("answer1", 42)
790 self.assertEqual(cache.get("answer1"), 42)
791 self.assertEqual(cache.get("answer1", version=1), 42)
792 self.assertIsNone(cache.get("answer1", version=2))
793
794 self.assertIsNone(caches["v2"].get("answer1"))
795 self.assertEqual(caches["v2"].get("answer1", version=1), 42)
796 self.assertIsNone(caches["v2"].get("answer1", version=2))
797
798 # set, default version = 1, but manually override version = 2
799 cache.set("answer2", 42, version=2)
800 self.assertIsNone(cache.get("answer2"))
801 self.assertIsNone(cache.get("answer2", version=1))
802 self.assertEqual(cache.get("answer2", version=2), 42)
803
804 self.assertEqual(caches["v2"].get("answer2"), 42)
805 self.assertIsNone(caches["v2"].get("answer2", version=1))
806 self.assertEqual(caches["v2"].get("answer2", version=2), 42)
807
808 # v2 set, using default version = 2
809 caches["v2"].set("answer3", 42)
810 self.assertIsNone(cache.get("answer3"))
811 self.assertIsNone(cache.get("answer3", version=1))
812 self.assertEqual(cache.get("answer3", version=2), 42)
813
814 self.assertEqual(caches["v2"].get("answer3"), 42)
815 self.assertIsNone(caches["v2"].get("answer3", version=1))
816 self.assertEqual(caches["v2"].get("answer3", version=2), 42)
817
818 # v2 set, default version = 2, but manually override version = 1
819 caches["v2"].set("answer4", 42, version=1)
820 self.assertEqual(cache.get("answer4"), 42)
821 self.assertEqual(cache.get("answer4", version=1), 42)
822 self.assertIsNone(cache.get("answer4", version=2))
823
824 self.assertIsNone(caches["v2"].get("answer4"))
825 self.assertEqual(caches["v2"].get("answer4", version=1), 42)
826 self.assertIsNone(caches["v2"].get("answer4", version=2))
827
828 def test_cache_versioning_add(self):
829 # add, default version = 1, but manually override version = 2
830 self.assertIs(cache.add("answer1", 42, version=2), True)
831 self.assertIsNone(cache.get("answer1", version=1))
832 self.assertEqual(cache.get("answer1", version=2), 42)
833
834 self.assertIs(cache.add("answer1", 37, version=2), False)
835 self.assertIsNone(cache.get("answer1", version=1))
836 self.assertEqual(cache.get("answer1", version=2), 42)
837
838 self.assertIs(cache.add("answer1", 37, version=1), True)
839 self.assertEqual(cache.get("answer1", version=1), 37)
840 self.assertEqual(cache.get("answer1", version=2), 42)
841
842 # v2 add, using default version = 2
843 self.assertIs(caches["v2"].add("answer2", 42), True)
844 self.assertIsNone(cache.get("answer2", version=1))
845 self.assertEqual(cache.get("answer2", version=2), 42)
846
847 self.assertIs(caches["v2"].add("answer2", 37), False)
848 self.assertIsNone(cache.get("answer2", version=1))
849 self.assertEqual(cache.get("answer2", version=2), 42)
850
851 self.assertIs(caches["v2"].add("answer2", 37, version=1), True)
852 self.assertEqual(cache.get("answer2", version=1), 37)
853 self.assertEqual(cache.get("answer2", version=2), 42)
854
855 # v2 add, default version = 2, but manually override version = 1
856 self.assertIs(caches["v2"].add("answer3", 42, version=1), True)
857 self.assertEqual(cache.get("answer3", version=1), 42)
858 self.assertIsNone(cache.get("answer3", version=2))
859
860 self.assertIs(caches["v2"].add("answer3", 37, version=1), False)
861 self.assertEqual(cache.get("answer3", version=1), 42)
862 self.assertIsNone(cache.get("answer3", version=2))
863
864 self.assertIs(caches["v2"].add("answer3", 37), True)
865 self.assertEqual(cache.get("answer3", version=1), 42)
866 self.assertEqual(cache.get("answer3", version=2), 37)
867
868 def test_cache_versioning_has_key(self):
869 cache.set("answer1", 42)
870
871 # has_key
872 self.assertIs(cache.has_key("answer1"), True)
873 self.assertIs(cache.has_key("answer1", version=1), True)
874 self.assertIs(cache.has_key("answer1", version=2), False)
875
876 self.assertIs(caches["v2"].has_key("answer1"), False)
877 self.assertIs(caches["v2"].has_key("answer1", version=1), True)
878 self.assertIs(caches["v2"].has_key("answer1", version=2), False)
879
880 def test_cache_versioning_delete(self):
881 cache.set("answer1", 37, version=1)
882 cache.set("answer1", 42, version=2)
883 self.assertIs(cache.delete("answer1"), True)
884 self.assertIsNone(cache.get("answer1", version=1))
885 self.assertEqual(cache.get("answer1", version=2), 42)
886
887 cache.set("answer2", 37, version=1)
888 cache.set("answer2", 42, version=2)
889 self.assertIs(cache.delete("answer2", version=2), True)
890 self.assertEqual(cache.get("answer2", version=1), 37)
891 self.assertIsNone(cache.get("answer2", version=2))
892
893 cache.set("answer3", 37, version=1)
894 cache.set("answer3", 42, version=2)
895 self.assertIs(caches["v2"].delete("answer3"), True)
896 self.assertEqual(cache.get("answer3", version=1), 37)
897 self.assertIsNone(cache.get("answer3", version=2))
898
899 cache.set("answer4", 37, version=1)
900 cache.set("answer4", 42, version=2)
901 self.assertIs(caches["v2"].delete("answer4", version=1), True)
902 self.assertIsNone(cache.get("answer4", version=1))
903 self.assertEqual(cache.get("answer4", version=2), 42)
904
905 def test_cache_versioning_incr_decr(self):
906 cache.set("answer1", 37, version=1)
907 cache.set("answer1", 42, version=2)
908 self.assertEqual(cache.incr("answer1"), 38)
909 self.assertEqual(cache.get("answer1", version=1), 38)
910 self.assertEqual(cache.get("answer1", version=2), 42)
911 self.assertEqual(cache.decr("answer1"), 37)
912 self.assertEqual(cache.get("answer1", version=1), 37)
913 self.assertEqual(cache.get("answer1", version=2), 42)
914
915 cache.set("answer2", 37, version=1)
916 cache.set("answer2", 42, version=2)
917 self.assertEqual(cache.incr("answer2", version=2), 43)
918 self.assertEqual(cache.get("answer2", version=1), 37)
919 self.assertEqual(cache.get("answer2", version=2), 43)
920 self.assertEqual(cache.decr("answer2", version=2), 42)
921 self.assertEqual(cache.get("answer2", version=1), 37)
922 self.assertEqual(cache.get("answer2", version=2), 42)
923
924 cache.set("answer3", 37, version=1)
925 cache.set("answer3", 42, version=2)
926 self.assertEqual(caches["v2"].incr("answer3"), 43)
927 self.assertEqual(cache.get("answer3", version=1), 37)
928 self.assertEqual(cache.get("answer3", version=2), 43)
929 self.assertEqual(caches["v2"].decr("answer3"), 42)
930 self.assertEqual(cache.get("answer3", version=1), 37)
931 self.assertEqual(cache.get("answer3", version=2), 42)
932
933 cache.set("answer4", 37, version=1)
934 cache.set("answer4", 42, version=2)
935 self.assertEqual(caches["v2"].incr("answer4", version=1), 38)
936 self.assertEqual(cache.get("answer4", version=1), 38)
937 self.assertEqual(cache.get("answer4", version=2), 42)
938 self.assertEqual(caches["v2"].decr("answer4", version=1), 37)
939 self.assertEqual(cache.get("answer4", version=1), 37)
940 self.assertEqual(cache.get("answer4", version=2), 42)
941
942 def test_cache_versioning_get_set_many(self):
943 # set, using default version = 1
944 cache.set_many({"ford1": 37, "arthur1": 42})
945 self.assertEqual(
946 cache.get_many(["ford1", "arthur1"]), {"ford1": 37, "arthur1": 42}
947 )
948 self.assertEqual(
949 cache.get_many(["ford1", "arthur1"], version=1),
950 {"ford1": 37, "arthur1": 42},
951 )
952 self.assertEqual(cache.get_many(["ford1", "arthur1"], version=2), {})
953
954 self.assertEqual(caches["v2"].get_many(["ford1", "arthur1"]), {})
955 self.assertEqual(
956 caches["v2"].get_many(["ford1", "arthur1"], version=1),
957 {"ford1": 37, "arthur1": 42},
958 )
959 self.assertEqual(caches["v2"].get_many(["ford1", "arthur1"], version=2), {})
960
961 # set, default version = 1, but manually override version = 2
962 cache.set_many({"ford2": 37, "arthur2": 42}, version=2)
963 self.assertEqual(cache.get_many(["ford2", "arthur2"]), {})
964 self.assertEqual(cache.get_many(["ford2", "arthur2"], version=1), {})
965 self.assertEqual(
966 cache.get_many(["ford2", "arthur2"], version=2),
967 {"ford2": 37, "arthur2": 42},
968 )
969
970 self.assertEqual(
971 caches["v2"].get_many(["ford2", "arthur2"]), {"ford2": 37, "arthur2": 42}
972 )
973 self.assertEqual(caches["v2"].get_many(["ford2", "arthur2"], version=1), {})
974 self.assertEqual(
975 caches["v2"].get_many(["ford2", "arthur2"], version=2),
976 {"ford2": 37, "arthur2": 42},
977 )
978
979 # v2 set, using default version = 2
980 caches["v2"].set_many({"ford3": 37, "arthur3": 42})
981 self.assertEqual(cache.get_many(["ford3", "arthur3"]), {})
982 self.assertEqual(cache.get_many(["ford3", "arthur3"], version=1), {})
983 self.assertEqual(
984 cache.get_many(["ford3", "arthur3"], version=2),
985 {"ford3": 37, "arthur3": 42},
986 )
987
988 self.assertEqual(
989 caches["v2"].get_many(["ford3", "arthur3"]), {"ford3": 37, "arthur3": 42}
990 )
991 self.assertEqual(caches["v2"].get_many(["ford3", "arthur3"], version=1), {})
992 self.assertEqual(
993 caches["v2"].get_many(["ford3", "arthur3"], version=2),
994 {"ford3": 37, "arthur3": 42},
995 )
996
997 # v2 set, default version = 2, but manually override version = 1
998 caches["v2"].set_many({"ford4": 37, "arthur4": 42}, version=1)
999 self.assertEqual(
1000 cache.get_many(["ford4", "arthur4"]), {"ford4": 37, "arthur4": 42}
1001 )
1002 self.assertEqual(
1003 cache.get_many(["ford4", "arthur4"], version=1),
1004 {"ford4": 37, "arthur4": 42},
1005 )
1006 self.assertEqual(cache.get_many(["ford4", "arthur4"], version=2), {})
1007
1008 self.assertEqual(caches["v2"].get_many(["ford4", "arthur4"]), {})
1009 self.assertEqual(
1010 caches["v2"].get_many(["ford4", "arthur4"], version=1),
1011 {"ford4": 37, "arthur4": 42},
1012 )
1013 self.assertEqual(caches["v2"].get_many(["ford4", "arthur4"], version=2), {})
1014
1015 def test_incr_version(self):
1016 cache.set("answer", 42, version=2)
1017 self.assertIsNone(cache.get("answer"))
1018 self.assertIsNone(cache.get("answer", version=1))
1019 self.assertEqual(cache.get("answer", version=2), 42)
1020 self.assertIsNone(cache.get("answer", version=3))
1021
1022 self.assertEqual(cache.incr_version("answer", version=2), 3)
1023 self.assertIsNone(cache.get("answer"))
1024 self.assertIsNone(cache.get("answer", version=1))
1025 self.assertIsNone(cache.get("answer", version=2))
1026 self.assertEqual(cache.get("answer", version=3), 42)
1027
1028 caches["v2"].set("answer2", 42)
1029 self.assertEqual(caches["v2"].get("answer2"), 42)
1030 self.assertIsNone(caches["v2"].get("answer2", version=1))
1031 self.assertEqual(caches["v2"].get("answer2", version=2), 42)
1032 self.assertIsNone(caches["v2"].get("answer2", version=3))
1033
1034 self.assertEqual(caches["v2"].incr_version("answer2"), 3)
1035 self.assertIsNone(caches["v2"].get("answer2"))
1036 self.assertIsNone(caches["v2"].get("answer2", version=1))
1037 self.assertIsNone(caches["v2"].get("answer2", version=2))
1038 self.assertEqual(caches["v2"].get("answer2", version=3), 42)
1039
1040 with self.assertRaises(ValueError):
1041 cache.incr_version("does_not_exist")
1042
1043 cache.set("null", None)
1044 self.assertEqual(cache.incr_version("null"), 2)
1045
1046 def test_decr_version(self):
1047 cache.set("answer", 42, version=2)
1048 self.assertIsNone(cache.get("answer"))
1049 self.assertIsNone(cache.get("answer", version=1))
1050 self.assertEqual(cache.get("answer", version=2), 42)
1051
1052 self.assertEqual(cache.decr_version("answer", version=2), 1)
1053 self.assertEqual(cache.get("answer"), 42)
1054 self.assertEqual(cache.get("answer", version=1), 42)
1055 self.assertIsNone(cache.get("answer", version=2))
1056
1057 caches["v2"].set("answer2", 42)
1058 self.assertEqual(caches["v2"].get("answer2"), 42)
1059 self.assertIsNone(caches["v2"].get("answer2", version=1))
1060 self.assertEqual(caches["v2"].get("answer2", version=2), 42)
1061
1062 self.assertEqual(caches["v2"].decr_version("answer2"), 1)
1063 self.assertIsNone(caches["v2"].get("answer2"))
1064 self.assertEqual(caches["v2"].get("answer2", version=1), 42)
1065 self.assertIsNone(caches["v2"].get("answer2", version=2))
1066
1067 with self.assertRaises(ValueError):
1068 cache.decr_version("does_not_exist", version=2)
1069
1070 cache.set("null", None, version=2)
1071 self.assertEqual(cache.decr_version("null", version=2), 1)
1072
1073 def test_custom_key_func(self):
1074 # Two caches with different key functions aren't visible to each other
1075 cache.set("answer1", 42)
1076 self.assertEqual(cache.get("answer1"), 42)
1077 self.assertIsNone(caches["custom_key"].get("answer1"))
1078 self.assertIsNone(caches["custom_key2"].get("answer1"))
1079
1080 caches["custom_key"].set("answer2", 42)
1081 self.assertIsNone(cache.get("answer2"))
1082 self.assertEqual(caches["custom_key"].get("answer2"), 42)
1083 self.assertEqual(caches["custom_key2"].get("answer2"), 42)
1084
1085 @override_settings(CACHE_MIDDLEWARE_ALIAS=DEFAULT_CACHE_ALIAS)
1086 def test_cache_write_unpicklable_object(self):
1087 fetch_middleware = FetchFromCacheMiddleware(empty_response)
1088
1089 request = self.factory.get("/cache/test")
1090 request._cache_update_cache = True
1091 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
1092 request
1093 )
1094 self.assertIsNone(get_cache_data)
1095
1096 content = "Testing cookie serialization."
1097
1098 def get_response(req):
1099 response = HttpResponse(content)
1100 response.set_cookie("foo", "bar")
1101 return response
1102
1103 update_middleware = UpdateCacheMiddleware(get_response)
1104 response = update_middleware(request)
1105
1106 get_cache_data = fetch_middleware.process_request(request)
1107 self.assertIsNotNone(get_cache_data)
1108 self.assertEqual(get_cache_data.content, content.encode())
1109 self.assertEqual(get_cache_data.cookies, response.cookies)
1110
1111 UpdateCacheMiddleware(lambda req: get_cache_data)(request)
1112 get_cache_data = fetch_middleware.process_request(request)
1113 self.assertIsNotNone(get_cache_data)
1114 self.assertEqual(get_cache_data.content, content.encode())
1115 self.assertEqual(get_cache_data.cookies, response.cookies)
1116
1117 def test_add_fail_on_pickleerror(self):
1118 # Shouldn't fail silently if trying to cache an unpicklable type.
1119 with self.assertRaises(pickle.PickleError):
1120 cache.add("unpicklable", Unpicklable())
1121
1122 def test_set_fail_on_pickleerror(self):
1123 with self.assertRaises(pickle.PickleError):
1124 cache.set("unpicklable", Unpicklable())
1125
1126 def test_get_or_set(self):
1127 self.assertIsNone(cache.get("projector"))
1128 self.assertEqual(cache.get_or_set("projector", 42), 42)
1129 self.assertEqual(cache.get("projector"), 42)
1130 self.assertIsNone(cache.get_or_set("null", None))
1131 # Previous get_or_set() stores None in the cache.
1132 self.assertIsNone(cache.get("null", "default"))
1133
1134 def test_get_or_set_callable(self):
1135 def my_callable():
1136 return "value"
1137
1138 self.assertEqual(cache.get_or_set("mykey", my_callable), "value")
1139 self.assertEqual(cache.get_or_set("mykey", my_callable()), "value")
1140
1141 self.assertIsNone(cache.get_or_set("null", lambda: None))
1142 # Previous get_or_set() stores None in the cache.
1143 self.assertIsNone(cache.get("null", "default"))
1144
1145 def test_get_or_set_version(self):
1146 msg = "get_or_set() missing 1 required positional argument: 'default'"
1147 self.assertEqual(cache.get_or_set("brian", 1979, version=2), 1979)
1148 with self.assertRaisesMessage(TypeError, msg):
1149 cache.get_or_set("brian")
1150 with self.assertRaisesMessage(TypeError, msg):
1151 cache.get_or_set("brian", version=1)
1152 self.assertIsNone(cache.get("brian", version=1))
1153 self.assertEqual(cache.get_or_set("brian", 42, version=1), 42)
1154 self.assertEqual(cache.get_or_set("brian", 1979, version=2), 1979)
1155 self.assertIsNone(cache.get("brian", version=3))
1156
1157 def test_get_or_set_racing(self):
1158 with mock.patch(
1159 "%s.%s" % (settings.CACHES["default"]["BACKEND"], "add")
1160 ) as cache_add:
1161 # Simulate cache.add() failing to add a value. In that case, the
1162 # default value should be returned.
1163 cache_add.return_value = False
1164 self.assertEqual(cache.get_or_set("key", "default"), "default")
1165
1166
1167 @override_settings(
1168 CACHES=caches_setting_for_tests(
1169 BACKEND="django.core.cache.backends.db.DatabaseCache",
1170 # Spaces are used in the table name to ensure quoting/escaping is working
1171 LOCATION="test cache table",
1172 )
1173 )
1174 class DBCacheTests(BaseCacheTests, TransactionTestCase):
1175 available_apps = ["cache"]
1176
1177 def setUp(self):
1178 # The super calls needs to happen first for the settings override.
1179 super().setUp()
1180 self.create_table()
1181 self.addCleanup(self.drop_table)
1182
1183 def create_table(self):
1184 management.call_command("createcachetable", verbosity=0)
1185
1186 def drop_table(self):
1187 with connection.cursor() as cursor:
1188 table_name = connection.ops.quote_name("test cache table")
1189 cursor.execute("DROP TABLE %s" % table_name)
1190
1191 def test_get_many_num_queries(self):
1192 cache.set_many({"a": 1, "b": 2})
1193 cache.set("expired", "expired", 0.01)
1194 with self.assertNumQueries(1):
1195 self.assertEqual(cache.get_many(["a", "b"]), {"a": 1, "b": 2})
1196 time.sleep(0.02)
1197 with self.assertNumQueries(2):
1198 self.assertEqual(cache.get_many(["a", "b", "expired"]), {"a": 1, "b": 2})
1199
1200 def test_delete_many_num_queries(self):
1201 cache.set_many({"a": 1, "b": 2, "c": 3})
1202 with self.assertNumQueries(1):
1203 cache.delete_many(["a", "b", "c"])
1204
1205 def test_cull_queries(self):
1206 old_max_entries = cache._max_entries
1207 # Force _cull to delete on first cached record.
1208 cache._max_entries = -1
1209 with CaptureQueriesContext(connection) as captured_queries:
1210 try:
1211 cache.set("force_cull", "value", 1000)
1212 finally:
1213 cache._max_entries = old_max_entries
1214 num_count_queries = sum("COUNT" in query["sql"] for query in captured_queries)
1215 self.assertEqual(num_count_queries, 1)
1216 # Column names are quoted.
1217 for query in captured_queries:
1218 sql = query["sql"]
1219 if "expires" in sql:
1220 self.assertIn(connection.ops.quote_name("expires"), sql)
1221 if "cache_key" in sql:
1222 self.assertIn(connection.ops.quote_name("cache_key"), sql)
1223
1224 def test_delete_cursor_rowcount(self):
1225 """
1226 The rowcount attribute should not be checked on a closed cursor.
1227 """
1228
1229 class MockedCursorWrapper(CursorWrapper):
1230 is_closed = False
1231
1232 def close(self):
1233 self.cursor.close()
1234 self.is_closed = True
1235
1236 @property
1237 def rowcount(self):
1238 if self.is_closed:
1239 raise Exception("Cursor is closed.")
1240 return self.cursor.rowcount
1241
1242 cache.set_many({"a": 1, "b": 2})
1243 with mock.patch("django.db.backends.utils.CursorWrapper", MockedCursorWrapper):
1244 self.assertIs(cache.delete("a"), True)
1245
1246 def test_zero_cull(self):
1247 self._perform_cull_test("zero_cull", 50, 18)
1248
1249 def test_second_call_doesnt_crash(self):
1250 out = io.StringIO()
1251 management.call_command("createcachetable", stdout=out)
1252 self.assertEqual(
1253 out.getvalue(),
1254 "Cache table 'test cache table' already exists.\n" * len(settings.CACHES),
1255 )
1256
1257 @override_settings(
1258 CACHES=caches_setting_for_tests(
1259 BACKEND="django.core.cache.backends.db.DatabaseCache",
1260 # Use another table name to avoid the 'table already exists' message.
1261 LOCATION="createcachetable_dry_run_mode",
1262 )
1263 )
1264 def test_createcachetable_dry_run_mode(self):
1265 out = io.StringIO()
1266 management.call_command("createcachetable", dry_run=True, stdout=out)
1267 output = out.getvalue()
1268 self.assertTrue(output.startswith("CREATE TABLE"))
1269
1270 def test_createcachetable_with_table_argument(self):
1271 """
1272 Delete and recreate cache table with legacy behavior (explicitly
1273 specifying the table name).
1274 """
1275 self.drop_table()
1276 out = io.StringIO()
1277 management.call_command(
1278 "createcachetable",
1279 "test cache table",
1280 verbosity=2,
1281 stdout=out,
1282 )
1283 self.assertEqual(out.getvalue(), "Cache table 'test cache table' created.\n")
1284
1285 def test_has_key_query_columns_quoted(self):
1286 with CaptureQueriesContext(connection) as captured_queries:
1287 cache.has_key("key")
1288 self.assertEqual(len(captured_queries), 1)
1289 sql = captured_queries[0]["sql"]
1290 # Column names are quoted.
1291 self.assertIn(connection.ops.quote_name("expires"), sql)
1292 self.assertIn(connection.ops.quote_name("cache_key"), sql)
1293
1294
1295 @override_settings(USE_TZ=True)
1296 class DBCacheWithTimeZoneTests(DBCacheTests):
1297 pass
1298
1299
1300 class DBCacheRouter:
1301 """A router that puts the cache table on the 'other' database."""
1302
1303 def db_for_read(self, model, **hints):
1304 if model._meta.app_label == "django_cache":
1305 return "other"
1306 return None
1307
1308 def db_for_write(self, model, **hints):
1309 if model._meta.app_label == "django_cache":
1310 return "other"
1311 return None
1312
1313 def allow_migrate(self, db, app_label, **hints):
1314 if app_label == "django_cache":
1315 return db == "other"
1316 return None
1317
1318
1319 @override_settings(
1320 CACHES={
1321 "default": {
1322 "BACKEND": "django.core.cache.backends.db.DatabaseCache",
1323 "LOCATION": "my_cache_table",
1324 },
1325 },
1326 )
1327 class CreateCacheTableForDBCacheTests(TestCase):
1328 databases = {"default", "other"}
1329
1330 @override_settings(DATABASE_ROUTERS=[DBCacheRouter()])
1331 def test_createcachetable_observes_database_router(self):
1332 # cache table should not be created on 'default'
1333 with self.assertNumQueries(0, using="default"):
1334 management.call_command("createcachetable", database="default", verbosity=0)
1335 # cache table should be created on 'other'
1336 # Queries:
1337 # 1: check table doesn't already exist
1338 # 2: create savepoint (if transactional DDL is supported)
1339 # 3: create the table
1340 # 4: create the index
1341 # 5: release savepoint (if transactional DDL is supported)
1342 num = 5 if connections["other"].features.can_rollback_ddl else 3
1343 with self.assertNumQueries(num, using="other"):
1344 management.call_command("createcachetable", database="other", verbosity=0)
1345
1346
1347 class PicklingSideEffect:
1348 def __init__(self, cache):
1349 self.cache = cache
1350 self.locked = False
1351
1352 def __getstate__(self):
1353 self.locked = self.cache._lock.locked()
1354 return {}
1355
1356
1357 limit_locmem_entries = override_settings(
1358 CACHES=caches_setting_for_tests(
1359 BACKEND="django.core.cache.backends.locmem.LocMemCache",
1360 OPTIONS={"MAX_ENTRIES": 9},
1361 )
1362 )
1363
1364
1365 @override_settings(
1366 CACHES=caches_setting_for_tests(
1367 BACKEND="django.core.cache.backends.locmem.LocMemCache",
1368 )
1369 )
1370 class LocMemCacheTests(BaseCacheTests, TestCase):
1371 def setUp(self):
1372 super().setUp()
1373
1374 # LocMem requires a hack to make the other caches
1375 # share a data store with the 'normal' cache.
1376 caches["prefix"]._cache = cache._cache
1377 caches["prefix"]._expire_info = cache._expire_info
1378
1379 caches["v2"]._cache = cache._cache
1380 caches["v2"]._expire_info = cache._expire_info
1381
1382 caches["custom_key"]._cache = cache._cache
1383 caches["custom_key"]._expire_info = cache._expire_info
1384
1385 caches["custom_key2"]._cache = cache._cache
1386 caches["custom_key2"]._expire_info = cache._expire_info
1387
1388 @override_settings(
1389 CACHES={
1390 "default": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache"},
1391 "other": {
1392 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
1393 "LOCATION": "other",
1394 },
1395 }
1396 )
1397 def test_multiple_caches(self):
1398 "Multiple locmem caches are isolated"
1399 cache.set("value", 42)
1400 self.assertEqual(caches["default"].get("value"), 42)
1401 self.assertIsNone(caches["other"].get("value"))
1402
1403 def test_locking_on_pickle(self):
1404 """#20613/#18541 -- Ensures pickling is done outside of the lock."""
1405 bad_obj = PicklingSideEffect(cache)
1406 cache.set("set", bad_obj)
1407 self.assertFalse(bad_obj.locked, "Cache was locked during pickling")
1408
1409 self.assertIs(cache.add("add", bad_obj), True)
1410 self.assertFalse(bad_obj.locked, "Cache was locked during pickling")
1411
1412 def test_incr_decr_timeout(self):
1413 """incr/decr does not modify expiry time (matches memcached behavior)"""
1414 key = "value"
1415 _key = cache.make_key(key)
1416 cache.set(key, 1, timeout=cache.default_timeout * 10)
1417 expire = cache._expire_info[_key]
1418 self.assertEqual(cache.incr(key), 2)
1419 self.assertEqual(expire, cache._expire_info[_key])
1420 self.assertEqual(cache.decr(key), 1)
1421 self.assertEqual(expire, cache._expire_info[_key])
1422
1423 @retry()
1424 @limit_locmem_entries
1425 def test_lru_get(self):
1426 """get() moves cache keys."""
1427 for key in range(9):
1428 cache.set(key, key, timeout=None)
1429 for key in range(6):
1430 self.assertEqual(cache.get(key), key)
1431 cache.set(9, 9, timeout=None)
1432 for key in range(6):
1433 self.assertEqual(cache.get(key), key)
1434 for key in range(6, 9):
1435 self.assertIsNone(cache.get(key))
1436 self.assertEqual(cache.get(9), 9)
1437
1438 @limit_locmem_entries
1439 def test_lru_set(self):
1440 """set() moves cache keys."""
1441 for key in range(9):
1442 cache.set(key, key, timeout=None)
1443 for key in range(3, 9):
1444 cache.set(key, key, timeout=None)
1445 cache.set(9, 9, timeout=None)
1446 for key in range(3, 10):
1447 self.assertEqual(cache.get(key), key)
1448 for key in range(3):
1449 self.assertIsNone(cache.get(key))
1450
1451 @retry()
1452 @limit_locmem_entries
1453 def test_lru_incr(self):
1454 """incr() moves cache keys."""
1455 for key in range(9):
1456 cache.set(key, key, timeout=None)
1457 for key in range(6):
1458 self.assertEqual(cache.incr(key), key + 1)
1459 cache.set(9, 9, timeout=None)
1460 for key in range(6):
1461 self.assertEqual(cache.get(key), key + 1)
1462 for key in range(6, 9):
1463 self.assertIsNone(cache.get(key))
1464 self.assertEqual(cache.get(9), 9)
1465
1466
1467 # memcached and redis backends aren't guaranteed to be available.
1468 # To check the backends, the test settings file will need to contain at least
1469 # one cache backend setting that points at your cache server.
1470 configured_caches = {}
1471 for _cache_params in settings.CACHES.values():
1472 configured_caches[_cache_params["BACKEND"]] = _cache_params
1473
1474 PyLibMCCache_params = configured_caches.get(
1475 "django.core.cache.backends.memcached.PyLibMCCache"
1476 )
1477 PyMemcacheCache_params = configured_caches.get(
1478 "django.core.cache.backends.memcached.PyMemcacheCache"
1479 )
1480
1481 # The memcached backends don't support cull-related options like `MAX_ENTRIES`.
1482 memcached_excluded_caches = {"cull", "zero_cull"}
1483
1484 RedisCache_params = configured_caches.get("django.core.cache.backends.redis.RedisCache")
1485
1486 # The redis backend does not support cull-related options like `MAX_ENTRIES`.
1487 redis_excluded_caches = {"cull", "zero_cull"}
1488
1489
1490 class BaseMemcachedTests(BaseCacheTests):
1491 # By default it's assumed that the client doesn't clean up connections
1492 # properly, in which case the backend must do so after each request.
1493 should_disconnect_on_close = True
1494
1495 def test_location_multiple_servers(self):
1496 locations = [
1497 ["server1.tld", "server2:11211"],
1498 "server1.tld;server2:11211",
1499 "server1.tld,server2:11211",
1500 ]
1501 for location in locations:
1502 with self.subTest(location=location):
1503 params = {"BACKEND": self.base_params["BACKEND"], "LOCATION": location}
1504 with self.settings(CACHES={"default": params}):
1505 self.assertEqual(cache._servers, ["server1.tld", "server2:11211"])
1506
1507 def _perform_invalid_key_test(self, key, expected_warning):
1508 """
1509 While other backends merely warn, memcached should raise for an invalid
1510 key.
1511 """
1512 msg = expected_warning.replace(key, cache.make_key(key))
1513 tests = [
1514 ("add", [key, 1]),
1515 ("get", [key]),
1516 ("set", [key, 1]),
1517 ("incr", [key]),
1518 ("decr", [key]),
1519 ("touch", [key]),
1520 ("delete", [key]),
1521 ("get_many", [[key, "b"]]),
1522 ("set_many", [{key: 1, "b": 2}]),
1523 ("delete_many", [[key, "b"]]),
1524 ]
1525 for operation, args in tests:
1526 with self.subTest(operation=operation):
1527 with self.assertRaises(InvalidCacheKey) as cm:
1528 getattr(cache, operation)(*args)
1529 self.assertEqual(str(cm.exception), msg)
1530
1531 def test_invalid_with_version_key_length(self):
1532 # make_key() adds a version to the key and exceeds the limit.
1533 key = "a" * 248
1534 expected_warning = (
1535 "Cache key will cause errors if used with memcached: "
1536 "%r (longer than %s)" % (key, 250)
1537 )
1538 self._perform_invalid_key_test(key, expected_warning)
1539
1540 def test_default_never_expiring_timeout(self):
1541 # Regression test for #22845
1542 with self.settings(
1543 CACHES=caches_setting_for_tests(
1544 base=self.base_params, exclude=memcached_excluded_caches, TIMEOUT=None
1545 )
1546 ):
1547 cache.set("infinite_foo", "bar")
1548 self.assertEqual(cache.get("infinite_foo"), "bar")
1549
1550 def test_default_far_future_timeout(self):
1551 # Regression test for #22845
1552 with self.settings(
1553 CACHES=caches_setting_for_tests(
1554 base=self.base_params,
1555 exclude=memcached_excluded_caches,
1556 # 60*60*24*365, 1 year
1557 TIMEOUT=31536000,
1558 )
1559 ):
1560 cache.set("future_foo", "bar")
1561 self.assertEqual(cache.get("future_foo"), "bar")
1562
1563 def test_memcached_deletes_key_on_failed_set(self):
1564 # By default memcached allows objects up to 1MB. For the cache_db session
1565 # backend to always use the current session, memcached needs to delete
1566 # the old key if it fails to set.
1567 max_value_length = 2**20
1568
1569 cache.set("small_value", "a")
1570 self.assertEqual(cache.get("small_value"), "a")
1571
1572 large_value = "a" * (max_value_length + 1)
1573 try:
1574 cache.set("small_value", large_value)
1575 except Exception:
1576 # Most clients (e.g. pymemcache or pylibmc) raise when the value is
1577 # too large. This test is primarily checking that the key was
1578 # deleted, so the return/exception behavior for the set() itself is
1579 # not important.
1580 pass
1581 # small_value should be deleted, or set if configured to accept larger values
1582 value = cache.get("small_value")
1583 self.assertTrue(value is None or value == large_value)
1584
1585 def test_close(self):
1586 # For clients that don't manage their connections properly, the
1587 # connection is closed when the request is complete.
1588 signals.request_finished.disconnect(close_old_connections)
1589 try:
1590 with mock.patch.object(
1591 cache._class, "disconnect_all", autospec=True
1592 ) as mock_disconnect:
1593 signals.request_finished.send(self.__class__)
1594 self.assertIs(mock_disconnect.called, self.should_disconnect_on_close)
1595 finally:
1596 signals.request_finished.connect(close_old_connections)
1597
1598 def test_set_many_returns_failing_keys(self):
1599 def fail_set_multi(mapping, *args, **kwargs):
1600 return mapping.keys()
1601
1602 with mock.patch.object(cache._class, "set_multi", side_effect=fail_set_multi):
1603 failing_keys = cache.set_many({"key": "value"})
1604 self.assertEqual(failing_keys, ["key"])
1605
1606
1607 @unittest.skipUnless(PyLibMCCache_params, "PyLibMCCache backend not configured")
1608 @override_settings(
1609 CACHES=caches_setting_for_tests(
1610 base=PyLibMCCache_params,
1611 exclude=memcached_excluded_caches,
1612 )
1613 )
1614 class PyLibMCCacheTests(BaseMemcachedTests, TestCase):
1615 base_params = PyLibMCCache_params
1616 # libmemcached manages its own connections.
1617 should_disconnect_on_close = False
1618
1619 @property
1620 def incr_decr_type_error(self):
1621 return cache._lib.ClientError
1622
1623 @override_settings(
1624 CACHES=caches_setting_for_tests(
1625 base=PyLibMCCache_params,
1626 exclude=memcached_excluded_caches,
1627 OPTIONS={
1628 "binary": True,
1629 "behaviors": {"tcp_nodelay": True},
1630 },
1631 )
1632 )
1633 def test_pylibmc_options(self):
1634 self.assertTrue(cache._cache.binary)
1635 self.assertEqual(cache._cache.behaviors["tcp_nodelay"], int(True))
1636
1637 def test_pylibmc_client_servers(self):
1638 backend = self.base_params["BACKEND"]
1639 tests = [
1640 ("unix:/run/memcached/socket", "/run/memcached/socket"),
1641 ("/run/memcached/socket", "/run/memcached/socket"),
1642 ("localhost", "localhost"),
1643 ("localhost:11211", "localhost:11211"),
1644 ("[::1]", "[::1]"),
1645 ("[::1]:11211", "[::1]:11211"),
1646 ("127.0.0.1", "127.0.0.1"),
1647 ("127.0.0.1:11211", "127.0.0.1:11211"),
1648 ]
1649 for location, expected in tests:
1650 settings = {"default": {"BACKEND": backend, "LOCATION": location}}
1651 with self.subTest(location), self.settings(CACHES=settings):
1652 self.assertEqual(cache.client_servers, [expected])
1653
1654
1655 @unittest.skipUnless(PyMemcacheCache_params, "PyMemcacheCache backend not configured")
1656 @override_settings(
1657 CACHES=caches_setting_for_tests(
1658 base=PyMemcacheCache_params,
1659 exclude=memcached_excluded_caches,
1660 )
1661 )
1662 class PyMemcacheCacheTests(BaseMemcachedTests, TestCase):
1663 base_params = PyMemcacheCache_params
1664
1665 @property
1666 def incr_decr_type_error(self):
1667 return cache._lib.exceptions.MemcacheClientError
1668
1669 def test_pymemcache_highest_pickle_version(self):
1670 self.assertEqual(
1671 cache._cache.default_kwargs["serde"]._serialize_func.keywords[
1672 "pickle_version"
1673 ],
1674 pickle.HIGHEST_PROTOCOL,
1675 )
1676 for cache_key in settings.CACHES:
1677 for client_key, client in caches[cache_key]._cache.clients.items():
1678 with self.subTest(cache_key=cache_key, server=client_key):
1679 self.assertEqual(
1680 client.serde._serialize_func.keywords["pickle_version"],
1681 pickle.HIGHEST_PROTOCOL,
1682 )
1683
1684 @override_settings(
1685 CACHES=caches_setting_for_tests(
1686 base=PyMemcacheCache_params,
1687 exclude=memcached_excluded_caches,
1688 OPTIONS={"no_delay": True},
1689 )
1690 )
1691 def test_pymemcache_options(self):
1692 self.assertIs(cache._cache.default_kwargs["no_delay"], True)
1693
1694
1695 @override_settings(
1696 CACHES=caches_setting_for_tests(
1697 BACKEND="django.core.cache.backends.filebased.FileBasedCache",
1698 )
1699 )
1700 class FileBasedCacheTests(BaseCacheTests, TestCase):
1701 """
1702 Specific test cases for the file-based cache.
1703 """
1704
1705 def setUp(self):
1706 super().setUp()
1707 self.dirname = self.mkdtemp()
1708 # Caches location cannot be modified through override_settings /
1709 # modify_settings, hence settings are manipulated directly here and the
1710 # setting_changed signal is triggered manually.
1711 for cache_params in settings.CACHES.values():
1712 cache_params["LOCATION"] = self.dirname
1713 setting_changed.send(self.__class__, setting="CACHES", enter=False)
1714
1715 def tearDown(self):
1716 super().tearDown()
1717 # Call parent first, as cache.clear() may recreate cache base directory
1718 shutil.rmtree(self.dirname)
1719
1720 def mkdtemp(self):
1721 return tempfile.mkdtemp()
1722
1723 def test_ignores_non_cache_files(self):
1724 fname = os.path.join(self.dirname, "not-a-cache-file")
1725 with open(fname, "w"):
1726 os.utime(fname, None)
1727 cache.clear()
1728 self.assertTrue(
1729 os.path.exists(fname), "Expected cache.clear to ignore non cache files"
1730 )
1731 os.remove(fname)
1732
1733 def test_clear_does_not_remove_cache_dir(self):
1734 cache.clear()
1735 self.assertTrue(
1736 os.path.exists(self.dirname), "Expected cache.clear to keep the cache dir"
1737 )
1738
1739 def test_creates_cache_dir_if_nonexistent(self):
1740 os.rmdir(self.dirname)
1741 cache.set("foo", "bar")
1742 self.assertTrue(os.path.exists(self.dirname))
1743
1744 def test_get_ignores_enoent(self):
1745 cache.set("foo", "bar")
1746 os.unlink(cache._key_to_file("foo"))
1747 # Returns the default instead of erroring.
1748 self.assertEqual(cache.get("foo", "baz"), "baz")
1749
1750 @skipIf(
1751 sys.platform == "win32",
1752 "Windows only partially supports umasks and chmod.",
1753 )
1754 def test_cache_dir_permissions(self):
1755 os.rmdir(self.dirname)
1756 dir_path = Path(self.dirname) / "nested" / "filebasedcache"
1757 for cache_params in settings.CACHES.values():
1758 cache_params["LOCATION"] = dir_path
1759 setting_changed.send(self.__class__, setting="CACHES", enter=False)
1760 cache.set("foo", "bar")
1761 self.assertIs(dir_path.exists(), True)
1762 tests = [
1763 dir_path,
1764 dir_path.parent,
1765 dir_path.parent.parent,
1766 ]
1767 for directory in tests:
1768 with self.subTest(directory=directory):
1769 dir_mode = directory.stat().st_mode & 0o777
1770 self.assertEqual(dir_mode, 0o700)
1771
1772 def test_get_does_not_ignore_non_filenotfound_exceptions(self):
1773 with mock.patch("builtins.open", side_effect=OSError):
1774 with self.assertRaises(OSError):
1775 cache.get("foo")
1776
1777 def test_empty_cache_file_considered_expired(self):
1778 cache_file = cache._key_to_file("foo")
1779 with open(cache_file, "wb") as fh:
1780 fh.write(b"")
1781 with open(cache_file, "rb") as fh:
1782 self.assertIs(cache._is_expired(fh), True)
1783
1784 def test_has_key_race_handling(self):
1785 self.assertIs(cache.add("key", "value"), True)
1786 with mock.patch("builtins.open", side_effect=FileNotFoundError) as mocked_open:
1787 self.assertIs(cache.has_key("key"), False)
1788 mocked_open.assert_called_once()
1789
1790 def test_touch(self):
1791 """Override to manually advance time since file access can be slow."""
1792
1793 class ManualTickingTime:
1794 def __init__(self):
1795 # Freeze time, calling `sleep` will manually advance it.
1796 self._time = time.time()
1797
1798 def time(self):
1799 return self._time
1800
1801 def sleep(self, seconds):
1802 self._time += seconds
1803
1804 mocked_time = ManualTickingTime()
1805 with (
1806 mock.patch("django.core.cache.backends.filebased.time", new=mocked_time),
1807 mock.patch("django.core.cache.backends.base.time", new=mocked_time),
1808 mock.patch("cache.tests.time", new=mocked_time),
1809 ):
1810 super().test_touch()
1811
1812
1813 @unittest.skipUnless(RedisCache_params, "Redis backend not configured")
1814 @override_settings(
1815 CACHES=caches_setting_for_tests(
1816 base=RedisCache_params,
1817 exclude=redis_excluded_caches,
1818 )
1819 )
1820 class RedisCacheTests(BaseCacheTests, TestCase):
1821 def setUp(self):
1822 import redis
1823
1824 super().setUp()
1825 self.lib = redis
1826
1827 @property
1828 def incr_decr_type_error(self):
1829 return self.lib.ResponseError
1830
1831 def test_incr_write_connection(self):
1832 cache.set("number", 42)
1833 with mock.patch(
1834 "django.core.cache.backends.redis.RedisCacheClient.get_client"
1835 ) as mocked_get_client:
1836 cache.incr("number")
1837 self.assertEqual(mocked_get_client.call_args.kwargs, {"write": True})
1838
1839 def test_cache_client_class(self):
1840 self.assertIs(cache._class, RedisCacheClient)
1841 self.assertIsInstance(cache._cache, RedisCacheClient)
1842
1843 def test_get_backend_timeout_method(self):
1844 positive_timeout = 10
1845 positive_backend_timeout = cache.get_backend_timeout(positive_timeout)
1846 self.assertEqual(positive_backend_timeout, positive_timeout)
1847
1848 negative_timeout = -5
1849 negative_backend_timeout = cache.get_backend_timeout(negative_timeout)
1850 self.assertEqual(negative_backend_timeout, 0)
1851
1852 none_timeout = None
1853 none_backend_timeout = cache.get_backend_timeout(none_timeout)
1854 self.assertIsNone(none_backend_timeout)
1855
1856 def test_get_connection_pool_index(self):
1857 pool_index = cache._cache._get_connection_pool_index(write=True)
1858 self.assertEqual(pool_index, 0)
1859 pool_index = cache._cache._get_connection_pool_index(write=False)
1860 if len(cache._cache._servers) == 1:
1861 self.assertEqual(pool_index, 0)
1862 else:
1863 self.assertGreater(pool_index, 0)
1864 self.assertLess(pool_index, len(cache._cache._servers))
1865
1866 def test_get_connection_pool(self):
1867 pool = cache._cache._get_connection_pool(write=True)
1868 self.assertIsInstance(pool, self.lib.ConnectionPool)
1869
1870 pool = cache._cache._get_connection_pool(write=False)
1871 self.assertIsInstance(pool, self.lib.ConnectionPool)
1872
1873 def test_get_client(self):
1874 self.assertIsInstance(cache._cache.get_client(), self.lib.Redis)
1875
1876 def test_serializer_dumps(self):
1877 self.assertEqual(cache._cache._serializer.dumps(123), 123)
1878 self.assertIsInstance(cache._cache._serializer.dumps(True), bytes)
1879 self.assertIsInstance(cache._cache._serializer.dumps("abc"), bytes)
1880
1881 @override_settings(
1882 CACHES=caches_setting_for_tests(
1883 base=RedisCache_params,
1884 exclude=redis_excluded_caches,
1885 OPTIONS={
1886 "db": 5,
1887 "socket_timeout": 0.1,
1888 "retry_on_timeout": True,
1889 },
1890 )
1891 )
1892 def test_redis_pool_options(self):
1893 pool = cache._cache._get_connection_pool(write=False)
1894 self.assertEqual(pool.connection_kwargs["db"], 5)
1895 self.assertEqual(pool.connection_kwargs["socket_timeout"], 0.1)
1896 self.assertIs(pool.connection_kwargs["retry_on_timeout"], True)
1897
1898
1899 class FileBasedCachePathLibTests(FileBasedCacheTests):
1900 def mkdtemp(self):
1901 tmp_dir = super().mkdtemp()
1902 return Path(tmp_dir)
1903
1904
1905 @override_settings(
1906 CACHES={
1907 "default": {
1908 "BACKEND": "cache.liberal_backend.CacheClass",
1909 },
1910 }
1911 )
1912 class CustomCacheKeyValidationTests(SimpleTestCase):
1913 """
1914 Tests for the ability to mixin a custom ``validate_key`` method to
1915 a custom cache backend that otherwise inherits from a builtin
1916 backend, and override the default key validation. Refs #6447.
1917 """
1918
1919 def test_custom_key_validation(self):
1920 # this key is both longer than 250 characters, and has spaces
1921 key = "some key with spaces" * 15
1922 val = "a value"
1923 cache.set(key, val)
1924 self.assertEqual(cache.get(key), val)
1925
1926
1927 @override_settings(
1928 CACHES={
1929 "default": {
1930 "BACKEND": "cache.closeable_cache.CacheClass",
1931 }
1932 }
1933 )
1934 class CacheClosingTests(SimpleTestCase):
1935 def test_close(self):
1936 self.assertFalse(cache.closed)
1937 signals.request_finished.send(self.__class__)
1938 self.assertTrue(cache.closed)
1939
1940 def test_close_only_initialized(self):
1941 with self.settings(
1942 CACHES={
1943 "cache_1": {
1944 "BACKEND": "cache.closeable_cache.CacheClass",
1945 },
1946 "cache_2": {
1947 "BACKEND": "cache.closeable_cache.CacheClass",
1948 },
1949 }
1950 ):
1951 self.assertEqual(caches.all(initialized_only=True), [])
1952 signals.request_finished.send(self.__class__)
1953 self.assertEqual(caches.all(initialized_only=True), [])
1954
1955
1956 DEFAULT_MEMORY_CACHES_SETTINGS = {
1957 "default": {
1958 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
1959 "LOCATION": "unique-snowflake",
1960 }
1961 }
1962 NEVER_EXPIRING_CACHES_SETTINGS = copy.deepcopy(DEFAULT_MEMORY_CACHES_SETTINGS)
1963 NEVER_EXPIRING_CACHES_SETTINGS["default"]["TIMEOUT"] = None
1964
1965
1966 class DefaultNonExpiringCacheKeyTests(SimpleTestCase):
1967 """
1968 Settings having Cache arguments with a TIMEOUT=None create Caches that will
1969 set non-expiring keys.
1970 """
1971
1972 def setUp(self):
1973 # The 5 minute (300 seconds) default expiration time for keys is
1974 # defined in the implementation of the initializer method of the
1975 # BaseCache type.
1976 self.DEFAULT_TIMEOUT = caches[DEFAULT_CACHE_ALIAS].default_timeout
1977
1978 def tearDown(self):
1979 del self.DEFAULT_TIMEOUT
1980
1981 def test_default_expiration_time_for_keys_is_5_minutes(self):
1982 """The default expiration time of a cache key is 5 minutes.
1983
1984 This value is defined in
1985 django.core.cache.backends.base.BaseCache.__init__().
1986 """
1987 self.assertEqual(300, self.DEFAULT_TIMEOUT)
1988
1989 def test_caches_with_unset_timeout_has_correct_default_timeout(self):
1990 """Caches that have the TIMEOUT parameter undefined in the default
1991 settings will use the default 5 minute timeout.
1992 """
1993 cache = caches[DEFAULT_CACHE_ALIAS]
1994 self.assertEqual(self.DEFAULT_TIMEOUT, cache.default_timeout)
1995
1996 @override_settings(CACHES=NEVER_EXPIRING_CACHES_SETTINGS)
1997 def test_caches_set_with_timeout_as_none_has_correct_default_timeout(self):
1998 """Memory caches that have the TIMEOUT parameter set to `None` in the
1999 default settings with have `None` as the default timeout.
2000
2001 This means "no timeout".
2002 """
2003 cache = caches[DEFAULT_CACHE_ALIAS]
2004 self.assertIsNone(cache.default_timeout)
2005 self.assertIsNone(cache.get_backend_timeout())
2006
2007 @override_settings(CACHES=DEFAULT_MEMORY_CACHES_SETTINGS)
2008 def test_caches_with_unset_timeout_set_expiring_key(self):
2009 """Memory caches that have the TIMEOUT parameter unset will set cache
2010 keys having the default 5 minute timeout.
2011 """
2012 key = "my-key"
2013 value = "my-value"
2014 cache = caches[DEFAULT_CACHE_ALIAS]
2015 cache.set(key, value)
2016 cache_key = cache.make_key(key)
2017 self.assertIsNotNone(cache._expire_info[cache_key])
2018
2019 @override_settings(CACHES=NEVER_EXPIRING_CACHES_SETTINGS)
2020 def test_caches_set_with_timeout_as_none_set_non_expiring_key(self):
2021 """Memory caches that have the TIMEOUT parameter set to `None` will set
2022 a non expiring key by default.
2023 """
2024 key = "another-key"
2025 value = "another-value"
2026 cache = caches[DEFAULT_CACHE_ALIAS]
2027 cache.set(key, value)
2028 cache_key = cache.make_key(key)
2029 self.assertIsNone(cache._expire_info[cache_key])
2030
2031
2032 @override_settings(
2033 CACHE_MIDDLEWARE_KEY_PREFIX="settingsprefix",
2034 CACHE_MIDDLEWARE_SECONDS=1,
2035 CACHES={
2036 "default": {
2037 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
2038 },
2039 },
2040 USE_I18N=False,
2041 ALLOWED_HOSTS=[".example.com"],
2042 )
2043 class CacheUtils(SimpleTestCase):
2044 """TestCase for django.utils.cache functions."""
2045
2046 host = "www.example.com"
2047 path = "/cache/test/"
2048 factory = RequestFactory(headers={"host": host})
2049
2050 def tearDown(self):
2051 cache.clear()
2052
2053 def _get_request_cache(self, method="GET", query_string=None, update_cache=None):
2054 request = self._get_request(
2055 self.host, self.path, method, query_string=query_string
2056 )
2057 request._cache_update_cache = update_cache if update_cache else True
2058 return request
2059
2060 def test_patch_vary_headers(self):
2061 headers = (
2062 # Initial vary, new headers, resulting vary.
2063 (None, ("Accept-Encoding",), "Accept-Encoding"),
2064 ("Accept-Encoding", ("accept-encoding",), "Accept-Encoding"),
2065 ("Accept-Encoding", ("ACCEPT-ENCODING",), "Accept-Encoding"),
2066 ("Cookie", ("Accept-Encoding",), "Cookie, Accept-Encoding"),
2067 (
2068 "Cookie, Accept-Encoding",
2069 ("Accept-Encoding",),
2070 "Cookie, Accept-Encoding",
2071 ),
2072 (
2073 "Cookie, Accept-Encoding",
2074 ("Accept-Encoding", "cookie"),
2075 "Cookie, Accept-Encoding",
2076 ),
2077 (None, ("Accept-Encoding", "COOKIE"), "Accept-Encoding, COOKIE"),
2078 (
2079 "Cookie, Accept-Encoding",
2080 ("Accept-Encoding", "cookie"),
2081 "Cookie, Accept-Encoding",
2082 ),
2083 (
2084 "Cookie , Accept-Encoding",
2085 ("Accept-Encoding", "cookie"),
2086 "Cookie, Accept-Encoding",
2087 ),
2088 ("*", ("Accept-Language", "Cookie"), "*"),
2089 ("Accept-Language, Cookie", ("*",), "*"),
2090 )
2091 for initial_vary, newheaders, resulting_vary in headers:
2092 with self.subTest(initial_vary=initial_vary, newheaders=newheaders):
2093 response = HttpResponse()
2094 if initial_vary is not None:
2095 response.headers["Vary"] = initial_vary
2096 patch_vary_headers(response, newheaders)
2097 self.assertEqual(response.headers["Vary"], resulting_vary)
2098
2099 def test_get_cache_key(self):
2100 request = self.factory.get(self.path)
2101 response = HttpResponse()
2102 # Expect None if no headers have been set yet.
2103 self.assertIsNone(get_cache_key(request))
2104 # Set headers to an empty list.
2105 learn_cache_key(request, response)
2106
2107 self.assertEqual(
2108 get_cache_key(request),
2109 "views.decorators.cache.cache_page.settingsprefix.GET."
2110 "18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e",
2111 )
2112 # A specified key_prefix is taken into account.
2113 key_prefix = "localprefix"
2114 learn_cache_key(request, response, key_prefix=key_prefix)
2115 self.assertEqual(
2116 get_cache_key(request, key_prefix=key_prefix),
2117 "views.decorators.cache.cache_page.localprefix.GET."
2118 "18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e",
2119 )
2120
2121 def test_get_cache_key_with_query(self):
2122 request = self.factory.get(self.path, {"test": 1})
2123 response = HttpResponse()
2124 # Expect None if no headers have been set yet.
2125 self.assertIsNone(get_cache_key(request))
2126 # Set headers to an empty list.
2127 learn_cache_key(request, response)
2128 # The querystring is taken into account.
2129 self.assertEqual(
2130 get_cache_key(request),
2131 "views.decorators.cache.cache_page.settingsprefix.GET."
2132 "beaf87a9a99ee81c673ea2d67ccbec2a.d41d8cd98f00b204e9800998ecf8427e",
2133 )
2134
2135 def test_cache_key_varies_by_url(self):
2136 """
2137 get_cache_key keys differ by fully-qualified URL instead of path
2138 """
2139 request1 = self.factory.get(self.path, headers={"host": "sub-1.example.com"})
2140 learn_cache_key(request1, HttpResponse())
2141 request2 = self.factory.get(self.path, headers={"host": "sub-2.example.com"})
2142 learn_cache_key(request2, HttpResponse())
2143 self.assertNotEqual(get_cache_key(request1), get_cache_key(request2))
2144
2145 def test_learn_cache_key(self):
2146 request = self.factory.head(self.path)
2147 response = HttpResponse()
2148 response.headers["Vary"] = "Pony"
2149 # Make sure that the Vary header is added to the key hash
2150 learn_cache_key(request, response)
2151
2152 self.assertEqual(
2153 get_cache_key(request),
2154 "views.decorators.cache.cache_page.settingsprefix.GET."
2155 "18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e",
2156 )
2157
2158 def test_patch_cache_control(self):
2159 tests = (
2160 # Initial Cache-Control, kwargs to patch_cache_control, expected
2161 # Cache-Control parts.
2162 (None, {"private": True}, {"private"}),
2163 ("", {"private": True}, {"private"}),
2164 # no-cache.
2165 ("", {"no_cache": "Set-Cookie"}, {"no-cache=Set-Cookie"}),
2166 ("", {"no-cache": "Set-Cookie"}, {"no-cache=Set-Cookie"}),
2167 ("no-cache=Set-Cookie", {"no_cache": True}, {"no-cache"}),
2168 ("no-cache=Set-Cookie,no-cache=Link", {"no_cache": True}, {"no-cache"}),
2169 (
2170 "no-cache=Set-Cookie",
2171 {"no_cache": "Link"},
2172 {"no-cache=Set-Cookie", "no-cache=Link"},
2173 ),
2174 (
2175 "no-cache=Set-Cookie,no-cache=Link",
2176 {"no_cache": "Custom"},
2177 {"no-cache=Set-Cookie", "no-cache=Link", "no-cache=Custom"},
2178 ),
2179 # Test whether private/public attributes are mutually exclusive
2180 ("private", {"private": True}, {"private"}),
2181 ("private", {"public": True}, {"public"}),
2182 ("public", {"public": True}, {"public"}),
2183 ("public", {"private": True}, {"private"}),
2184 (
2185 "must-revalidate,max-age=60,private",
2186 {"public": True},
2187 {"must-revalidate", "max-age=60", "public"},
2188 ),
2189 (
2190 "must-revalidate,max-age=60,public",
2191 {"private": True},
2192 {"must-revalidate", "max-age=60", "private"},
2193 ),
2194 (
2195 "must-revalidate,max-age=60",
2196 {"public": True},
2197 {"must-revalidate", "max-age=60", "public"},
2198 ),
2199 )
2200
2201 for initial_cc, newheaders, expected_cc in tests:
2202 with self.subTest(initial_cc=initial_cc, newheaders=newheaders):
2203 response = HttpResponse()
2204 if initial_cc is not None:
2205 response.headers["Cache-Control"] = initial_cc
2206 patch_cache_control(response, **newheaders)
2207 parts = set(cc_delim_re.split(response.headers["Cache-Control"]))
2208 self.assertEqual(parts, expected_cc)
2209
2210 def test_has_vary_header(self):
2211 tests = [
2212 ("*", "*", True),
2213 ("Cookie, *", "*", True),
2214 ("Cookie,*", "*", True),
2215 ("Cookie , *", "*", True),
2216 # Surronding whitespace on values must be stripped independently of
2217 # the comma delimiter.
2218 ("* ", "*", True),
2219 (" *", "*", True),
2220 ("Cookie, * ", "*", True),
2221 (" Cookie", "Cookie", True),
2222 ("Cookie", "*", False),
2223 ("*", "Cookie", False),
2224 ("cookie", "Cookie", True),
2225 ("Cookie", "cookie", True),
2226 ]
2227
2228 for header_value, header_query, has_match in tests:
2229 with self.subTest(header_value=header_value, header_query=header_query):
2230 response = HttpResponse()
2231 response.headers["Vary"] = header_value
2232
2233 self.assertIs(has_vary_header(response, header_query), has_match)
2234
2235
2236 @override_settings(
2237 CACHES={
2238 "default": {
2239 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
2240 "KEY_PREFIX": "cacheprefix",
2241 },
2242 },
2243 )
2244 class PrefixedCacheUtils(CacheUtils):
2245 pass
2246
2247
2248 @override_settings(
2249 CACHE_MIDDLEWARE_SECONDS=60,
2250 CACHE_MIDDLEWARE_KEY_PREFIX="test",
2251 CACHES={
2252 "default": {
2253 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
2254 },
2255 },
2256 )
2257 class CacheHEADTest(SimpleTestCase):
2258 path = "/cache/test/"
2259 factory = RequestFactory()
2260
2261 def tearDown(self):
2262 cache.clear()
2263
2264 def _set_cache(self, request, msg):
2265 return UpdateCacheMiddleware(lambda req: HttpResponse(msg))(request)
2266
2267 def test_head_caches_correctly(self):
2268 test_content = "test content"
2269
2270 request = self.factory.head(self.path)
2271 request._cache_update_cache = True
2272 self._set_cache(request, test_content)
2273
2274 request = self.factory.head(self.path)
2275 request._cache_update_cache = True
2276 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2277 request
2278 )
2279 self.assertIsNotNone(get_cache_data)
2280 self.assertEqual(test_content.encode(), get_cache_data.content)
2281
2282 def test_head_with_cached_get(self):
2283 test_content = "test content"
2284
2285 request = self.factory.get(self.path)
2286 request._cache_update_cache = True
2287 self._set_cache(request, test_content)
2288
2289 request = self.factory.head(self.path)
2290 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2291 request
2292 )
2293 self.assertIsNotNone(get_cache_data)
2294 self.assertEqual(test_content.encode(), get_cache_data.content)
2295
2296
2297 @override_settings(
2298 CACHE_MIDDLEWARE_KEY_PREFIX="settingsprefix",
2299 CACHES={
2300 "default": {
2301 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
2302 },
2303 },
2304 LANGUAGES=[
2305 ("en", "English"),
2306 ("es", "Spanish"),
2307 ],
2308 )
2309 class CacheI18nTest(SimpleTestCase):
2310 path = "/cache/test/"
2311 factory = RequestFactory()
2312
2313 def tearDown(self):
2314 cache.clear()
2315
2316 @override_settings(USE_I18N=True, USE_TZ=False)
2317 def test_cache_key_i18n_translation(self):
2318 request = self.factory.get(self.path)
2319 lang = translation.get_language()
2320 response = HttpResponse()
2321 key = learn_cache_key(request, response)
2322 self.assertIn(
2323 lang,
2324 key,
2325 "Cache keys should include the language name when translation is active",
2326 )
2327 key2 = get_cache_key(request)
2328 self.assertEqual(key, key2)
2329
2330 def check_accept_language_vary(self, accept_language, vary, reference_key):
2331 request = self.factory.get(self.path)
2332 request.META["HTTP_ACCEPT_LANGUAGE"] = accept_language
2333 request.META["HTTP_ACCEPT_ENCODING"] = "gzip;q=1.0, identity; q=0.5, *;q=0"
2334 response = HttpResponse()
2335 response.headers["Vary"] = vary
2336 key = learn_cache_key(request, response)
2337 key2 = get_cache_key(request)
2338 self.assertEqual(key, reference_key)
2339 self.assertEqual(key2, reference_key)
2340
2341 @override_settings(USE_I18N=True, USE_TZ=False)
2342 def test_cache_key_i18n_translation_accept_language(self):
2343 lang = translation.get_language()
2344 self.assertEqual(lang, "en")
2345 request = self.factory.get(self.path)
2346 request.META["HTTP_ACCEPT_ENCODING"] = "gzip;q=1.0, identity; q=0.5, *;q=0"
2347 response = HttpResponse()
2348 response.headers["Vary"] = "accept-encoding"
2349 key = learn_cache_key(request, response)
2350 self.assertIn(
2351 lang,
2352 key,
2353 "Cache keys should include the language name when translation is active",
2354 )
2355 self.check_accept_language_vary(
2356 "en-us", "cookie, accept-language, accept-encoding", key
2357 )
2358 self.check_accept_language_vary(
2359 "en-US", "cookie, accept-encoding, accept-language", key
2360 )
2361 self.check_accept_language_vary(
2362 "en-US,en;q=0.8", "accept-encoding, accept-language, cookie", key
2363 )
2364 self.check_accept_language_vary(
2365 "en-US,en;q=0.8,ko;q=0.6", "accept-language, cookie, accept-encoding", key
2366 )
2367 self.check_accept_language_vary(
2368 "ko-kr,ko;q=0.8,en-us;q=0.5,en;q=0.3 ",
2369 "accept-encoding, cookie, accept-language",
2370 key,
2371 )
2372 self.check_accept_language_vary(
2373 "ko-KR,ko;q=0.8,en-US;q=0.6,en;q=0.4",
2374 "accept-language, accept-encoding, cookie",
2375 key,
2376 )
2377 self.check_accept_language_vary(
2378 "ko;q=1.0,en;q=0.5", "cookie, accept-language, accept-encoding", key
2379 )
2380 self.check_accept_language_vary(
2381 "ko, en", "cookie, accept-encoding, accept-language", key
2382 )
2383 self.check_accept_language_vary(
2384 "ko-KR, en-US", "accept-encoding, accept-language, cookie", key
2385 )
2386
2387 @override_settings(USE_I18N=False, USE_TZ=True)
2388 def test_cache_key_i18n_timezone(self):
2389 request = self.factory.get(self.path)
2390 tz = timezone.get_current_timezone_name()
2391 response = HttpResponse()
2392 key = learn_cache_key(request, response)
2393 self.assertIn(
2394 tz,
2395 key,
2396 "Cache keys should include the time zone name when time zones are active",
2397 )
2398 key2 = get_cache_key(request)
2399 self.assertEqual(key, key2)
2400
2401 @override_settings(USE_I18N=False)
2402 def test_cache_key_no_i18n(self):
2403 request = self.factory.get(self.path)
2404 lang = translation.get_language()
2405 tz = timezone.get_current_timezone_name()
2406 response = HttpResponse()
2407 key = learn_cache_key(request, response)
2408 self.assertNotIn(
2409 lang,
2410 key,
2411 "Cache keys shouldn't include the language name when i18n isn't active",
2412 )
2413 self.assertNotIn(
2414 tz,
2415 key,
2416 "Cache keys shouldn't include the time zone name when i18n isn't active",
2417 )
2418
2419 @override_settings(
2420 CACHE_MIDDLEWARE_KEY_PREFIX="test",
2421 CACHE_MIDDLEWARE_SECONDS=60,
2422 USE_I18N=True,
2423 )
2424 def test_middleware(self):
2425 def set_cache(request, lang, msg):
2426 def get_response(req):
2427 return HttpResponse(msg)
2428
2429 translation.activate(lang)
2430 return UpdateCacheMiddleware(get_response)(request)
2431
2432 # cache with non empty request.GET
2433 request = self.factory.get(self.path, {"foo": "bar", "other": "true"})
2434 request._cache_update_cache = True
2435
2436 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2437 request
2438 )
2439 # first access, cache must return None
2440 self.assertIsNone(get_cache_data)
2441 content = "Check for cache with QUERY_STRING"
2442
2443 def get_response(req):
2444 return HttpResponse(content)
2445
2446 UpdateCacheMiddleware(get_response)(request)
2447 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2448 request
2449 )
2450 # cache must return content
2451 self.assertIsNotNone(get_cache_data)
2452 self.assertEqual(get_cache_data.content, content.encode())
2453 # different QUERY_STRING, cache must be empty
2454 request = self.factory.get(self.path, {"foo": "bar", "somethingelse": "true"})
2455 request._cache_update_cache = True
2456 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2457 request
2458 )
2459 self.assertIsNone(get_cache_data)
2460
2461 # i18n tests
2462 en_message = "Hello world!"
2463 es_message = "Hola mundo!"
2464
2465 request = self.factory.get(self.path)
2466 request._cache_update_cache = True
2467 set_cache(request, "en", en_message)
2468 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2469 request
2470 )
2471 # The cache can be recovered
2472 self.assertIsNotNone(get_cache_data)
2473 self.assertEqual(get_cache_data.content, en_message.encode())
2474 # change the session language and set content
2475 request = self.factory.get(self.path)
2476 request._cache_update_cache = True
2477 set_cache(request, "es", es_message)
2478 # change again the language
2479 translation.activate("en")
2480 # retrieve the content from cache
2481 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2482 request
2483 )
2484 self.assertEqual(get_cache_data.content, en_message.encode())
2485 # change again the language
2486 translation.activate("es")
2487 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2488 request
2489 )
2490 self.assertEqual(get_cache_data.content, es_message.encode())
2491 # reset the language
2492 translation.deactivate()
2493
2494 @override_settings(
2495 CACHE_MIDDLEWARE_KEY_PREFIX="test",
2496 CACHE_MIDDLEWARE_SECONDS=60,
2497 )
2498 def test_middleware_doesnt_cache_streaming_response(self):
2499 request = self.factory.get(self.path)
2500 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2501 request
2502 )
2503 self.assertIsNone(get_cache_data)
2504
2505 def get_stream_response(req):
2506 return StreamingHttpResponse(["Check for cache with streaming content."])
2507
2508 UpdateCacheMiddleware(get_stream_response)(request)
2509
2510 get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
2511 request
2512 )
2513 self.assertIsNone(get_cache_data)
2514
2515
2516 @override_settings(
2517 CACHES={
2518 "default": {
2519 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
2520 "KEY_PREFIX": "cacheprefix",
2521 },
2522 },
2523 )
2524 class PrefixedCacheI18nTest(CacheI18nTest):
2525 pass
2526
2527
2528 def hello_world_view(request, value):
2529 return HttpResponse("Hello World %s" % value)
2530
2531
2532 def hello_world_view_patch_vary_headers_asterisk(request, value):
2533 response = HttpResponse("Hello World %s" % value)
2534 patch_vary_headers(response, ("*",))
2535 return response
2536
2537
2538 def hello_world_view_patch_vary_headers_asterisk_space(request, value):
2539 response = HttpResponse("Hello World %s" % value)
2540 patch_vary_headers(response, (" * ",))
2541 return response
2542
2543
2544 def hello_world_view_vary_headers_includes_asterisk(request, value):
2545 response = HttpResponse("Hello World %s" % value)
2546 response["Vary"] = "Cookie, * , Pony"
2547 return response
2548
2549
2550 def csrf_view(request):
2551 return HttpResponse(csrf(request)["csrf_token"])
2552
2553
2554 @override_settings(
2555 CACHE_MIDDLEWARE_ALIAS="other",
2556 CACHE_MIDDLEWARE_KEY_PREFIX="middlewareprefix",
2557 CACHE_MIDDLEWARE_SECONDS=30,
2558 CACHES={
2559 "default": {
2560 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
2561 },
2562 "other": {
2563 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
2564 "LOCATION": "other",
2565 "TIMEOUT": "1",
2566 },
2567 },
2568 )
2569 class CacheMiddlewareTest(SimpleTestCase):
2570 factory = RequestFactory()
2571
2572 def setUp(self):
2573 self.default_cache = caches["default"]
2574 self.addCleanup(self.default_cache.clear)
2575 self.other_cache = caches["other"]
2576 self.addCleanup(self.other_cache.clear)
2577
2578 def test_constructor(self):
2579 """
2580 The constructor is correctly distinguishing between usage of
2581 CacheMiddleware as Middleware vs. usage of CacheMiddleware as view
2582 decorator and setting attributes appropriately.
2583 """
2584 # If only one argument is passed in construction, it's being used as
2585 # middleware.
2586 middleware = CacheMiddleware(empty_response)
2587
2588 # Now test object attributes against values defined in setUp above
2589 self.assertEqual(middleware.cache_timeout, 30)
2590 self.assertEqual(middleware.key_prefix, "middlewareprefix")
2591 self.assertEqual(middleware.cache_alias, "other")
2592 self.assertEqual(middleware.cache, self.other_cache)
2593
2594 # If more arguments are being passed in construction, it's being used
2595 # as a decorator. First, test with "defaults":
2596 as_view_decorator = CacheMiddleware(
2597 empty_response, cache_alias=None, key_prefix=None
2598 )
2599
2600 self.assertEqual(
2601 as_view_decorator.cache_timeout, 30
2602 ) # Timeout value for 'default' cache, i.e. 30
2603 self.assertEqual(as_view_decorator.key_prefix, "")
2604 # Value of DEFAULT_CACHE_ALIAS from django.core.cache
2605 self.assertEqual(as_view_decorator.cache_alias, "default")
2606 self.assertEqual(as_view_decorator.cache, self.default_cache)
2607
2608 # Next, test with custom values:
2609 as_view_decorator_with_custom = CacheMiddleware(
2610 hello_world_view, cache_timeout=60, cache_alias="other", key_prefix="foo"
2611 )
2612
2613 self.assertEqual(as_view_decorator_with_custom.cache_timeout, 60)
2614 self.assertEqual(as_view_decorator_with_custom.key_prefix, "foo")
2615 self.assertEqual(as_view_decorator_with_custom.cache_alias, "other")
2616 self.assertEqual(as_view_decorator_with_custom.cache, self.other_cache)
2617
2618 def test_update_cache_middleware_constructor(self):
2619 middleware = UpdateCacheMiddleware(empty_response)
2620 self.assertEqual(middleware.cache_timeout, 30)
2621 self.assertIsNone(middleware.page_timeout)
2622 self.assertEqual(middleware.key_prefix, "middlewareprefix")
2623 self.assertEqual(middleware.cache_alias, "other")
2624 self.assertEqual(middleware.cache, self.other_cache)
2625
2626 def test_fetch_cache_middleware_constructor(self):
2627 middleware = FetchFromCacheMiddleware(empty_response)
2628 self.assertEqual(middleware.key_prefix, "middlewareprefix")
2629 self.assertEqual(middleware.cache_alias, "other")
2630 self.assertEqual(middleware.cache, self.other_cache)
2631
2632 def test_middleware(self):
2633 middleware = CacheMiddleware(hello_world_view)
2634 prefix_middleware = CacheMiddleware(hello_world_view, key_prefix="prefix1")
2635 timeout_middleware = CacheMiddleware(hello_world_view, cache_timeout=1)
2636
2637 request = self.factory.get("/view/")
2638
2639 # Put the request through the request middleware
2640 result = middleware.process_request(request)
2641 self.assertIsNone(result)
2642
2643 response = hello_world_view(request, "1")
2644
2645 # Now put the response through the response middleware
2646 response = middleware.process_response(request, response)
2647
2648 # Repeating the request should result in a cache hit
2649 result = middleware.process_request(request)
2650 self.assertIsNotNone(result)
2651 self.assertEqual(result.content, b"Hello World 1")
2652
2653 # The same request through a different middleware won't hit
2654 result = prefix_middleware.process_request(request)
2655 self.assertIsNone(result)
2656
2657 # The same request with a timeout _will_ hit
2658 result = timeout_middleware.process_request(request)
2659 self.assertIsNotNone(result)
2660 self.assertEqual(result.content, b"Hello World 1")
2661
2662 def test_view_decorator(self):
2663 # decorate the same view with different cache decorators
2664 default_view = cache_page(3)(hello_world_view)
2665 default_with_prefix_view = cache_page(3, key_prefix="prefix1")(hello_world_view)
2666
2667 explicit_default_view = cache_page(3, cache="default")(hello_world_view)
2668 explicit_default_with_prefix_view = cache_page(
2669 3, cache="default", key_prefix="prefix1"
2670 )(hello_world_view)
2671
2672 other_view = cache_page(1, cache="other")(hello_world_view)
2673 other_with_prefix_view = cache_page(1, cache="other", key_prefix="prefix2")(
2674 hello_world_view
2675 )
2676
2677 request = self.factory.get("/view/")
2678
2679 # Request the view once
2680 response = default_view(request, "1")
2681 self.assertEqual(response.content, b"Hello World 1")
2682
2683 # Request again -- hit the cache
2684 response = default_view(request, "2")
2685 self.assertEqual(response.content, b"Hello World 1")
2686
2687 # Requesting the same view with the explicit cache should yield the same result
2688 response = explicit_default_view(request, "3")
2689 self.assertEqual(response.content, b"Hello World 1")
2690
2691 # Requesting with a prefix will hit a different cache key
2692 response = explicit_default_with_prefix_view(request, "4")
2693 self.assertEqual(response.content, b"Hello World 4")
2694
2695 # Hitting the same view again gives a cache hit
2696 response = explicit_default_with_prefix_view(request, "5")
2697 self.assertEqual(response.content, b"Hello World 4")
2698
2699 # And going back to the implicit cache will hit the same cache
2700 response = default_with_prefix_view(request, "6")
2701 self.assertEqual(response.content, b"Hello World 4")
2702
2703 # Requesting from an alternate cache won't hit cache
2704 response = other_view(request, "7")
2705 self.assertEqual(response.content, b"Hello World 7")
2706
2707 # But a repeated hit will hit cache
2708 response = other_view(request, "8")
2709 self.assertEqual(response.content, b"Hello World 7")
2710
2711 # And prefixing the alternate cache yields yet another cache entry
2712 response = other_with_prefix_view(request, "9")
2713 self.assertEqual(response.content, b"Hello World 9")
2714
2715 # But if we wait a couple of seconds...
2716 time.sleep(2)
2717
2718 # ... the default cache will still hit
2719 caches["default"]
2720 response = default_view(request, "11")
2721 self.assertEqual(response.content, b"Hello World 1")
2722
2723 # ... the default cache with a prefix will still hit
2724 response = default_with_prefix_view(request, "12")
2725 self.assertEqual(response.content, b"Hello World 4")
2726
2727 # ... the explicit default cache will still hit
2728 response = explicit_default_view(request, "13")
2729 self.assertEqual(response.content, b"Hello World 1")
2730
2731 # ... the explicit default cache with a prefix will still hit
2732 response = explicit_default_with_prefix_view(request, "14")
2733 self.assertEqual(response.content, b"Hello World 4")
2734
2735 # .. but a rapidly expiring cache won't hit
2736 response = other_view(request, "15")
2737 self.assertEqual(response.content, b"Hello World 15")
2738
2739 # .. even if it has a prefix
2740 response = other_with_prefix_view(request, "16")
2741 self.assertEqual(response.content, b"Hello World 16")
2742
2743 @retry()
2744 def test_cache_page_timeout(self):
2745 # Page timeout takes precedence over the "max-age" section of the
2746 # "Cache-Control".
2747 tests = [
2748 (1, 3), # max_age < page_timeout.
2749 (3, 1), # max_age > page_timeout.
2750 ]
2751 for max_age, page_timeout in tests:
2752 with self.subTest(max_age=max_age, page_timeout=page_timeout):
2753 view = cache_page(timeout=page_timeout)(
2754 cache_control(max_age=max_age)(hello_world_view)
2755 )
2756 request = self.factory.get("/view/")
2757 response = view(request, "1")
2758 self.assertEqual(response.content, b"Hello World 1")
2759 time.sleep(1)
2760 response = view(request, "2")
2761 self.assertEqual(
2762 response.content,
2763 b"Hello World 1" if page_timeout > max_age else b"Hello World 2",
2764 )
2765 cache.clear()
2766
2767 def test_cache_control_not_cached(self):
2768 """
2769 Responses with 'Cache-Control: private/no-cache/no-store' are
2770 not cached.
2771 """
2772 for cc in ("private", "no-cache", "no-store", "PRIVATE", "NO-store"):
2773 with self.subTest(cache_control=cc):
2774 # Cannot use @cache_control() as it lowercases directives.
2775 @cache_page(3)
2776 def view(request, value):
2777 return HttpResponse(
2778 f"Hello World {value}", headers={"Cache-Control": cc}
2779 )
2780
2781 request = self.factory.get("/view/")
2782 response = view(request, "1")
2783 self.assertEqual(response.content, b"Hello World 1")
2784 response = view(request, "2")
2785 self.assertEqual(response.content, b"Hello World 2")
2786
2787 def test_vary_asterisk_not_cached(self):
2788 views_with_cache = (
2789 cache_page(3)(hello_world_view_patch_vary_headers_asterisk),
2790 cache_page(3)(hello_world_view_patch_vary_headers_asterisk_space),
2791 cache_page(3)(hello_world_view_vary_headers_includes_asterisk),
2792 )
2793 for view in views_with_cache:
2794 with self.subTest(view=view):
2795 request = self.factory.get("/view/")
2796 response = view(request, "1")
2797 self.assertEqual(response.content, b"Hello World 1")
2798 response = view(request, "2")
2799 self.assertEqual(response.content, b"Hello World 2")
2800
2801 def test_vary_on_authorization_for_authorization_header(self):
2802 view_with_cache = cache_page(3)(hello_world_view)
2803 request = self.factory.get("/view/", headers={"Authorization": "token"})
2804 response = view_with_cache(request, "1")
2805 self.assertIs(has_vary_header(response, "Authorization"), True)
2806
2807 def test_no_vary_on_authorization_for_empty_authorization_header(self):
2808 view_with_cache = cache_page(3)(hello_world_view)
2809 request = self.factory.get("/view/", headers={"Authorization": ""})
2810 response = view_with_cache(request, "1")
2811 self.assertIs(has_vary_header(response, "Authorization"), False)
2812
2813 def test_authorization_header_exceptions(self):
2814 """
2815 Responses to requests with an ``Authorization`` header are not made to
2816 vary on ``Authorization`` when ``Cache-Control: public`` is present.
2817 ``s-maxage`` and ``must-revalidate`` are also exceptions per RFC 9111,
2818 Section 3.5, but Django does not implement them.
2819 """
2820 view_with_cache = cache_page(3)(cache_control(public=True)(hello_world_view))
2821 request = self.factory.get("/view/", headers={"Authorization": "token"})
2822 response = view_with_cache(request, "1")
2823 self.assertIs(has_vary_header(response, "Authorization"), False)
2824
2825 def test_sensitive_cookie_not_cached(self):
2826 """
2827 Django must prevent caching of responses that set a user-specific (and
2828 maybe security sensitive) cookie in response to a cookie-less request.
2829 """
2830 request = self.factory.get("/view/")
2831 csrf_middleware = CsrfViewMiddleware(csrf_view)
2832 csrf_middleware.process_view(request, csrf_view, (), {})
2833 cache_middleware = CacheMiddleware(csrf_middleware)
2834
2835 self.assertIsNone(cache_middleware.process_request(request))
2836 cache_middleware(request)
2837
2838 # Inserting a CSRF cookie in a cookie-less request prevented caching.
2839 self.assertIsNone(cache_middleware.process_request(request))
2840
2841 def test_304_response_has_http_caching_headers_but_not_cached(self):
2842 original_view = mock.Mock(return_value=HttpResponseNotModified())
2843 view = cache_page(2)(original_view)
2844 request = self.factory.get("/view/")
2845 # The view shouldn't be cached on the second call.
2846 view(request).close()
2847 response = view(request)
2848 response.close()
2849 self.assertEqual(original_view.call_count, 2)
2850 self.assertIsInstance(response, HttpResponseNotModified)
2851 self.assertIn("Cache-Control", response)
2852 self.assertIn("Expires", response)
2853
2854 def test_per_thread(self):
2855 """The cache instance is different for each thread."""
2856 thread_caches = []
2857 middleware = CacheMiddleware(empty_response)
2858
2859 def runner():
2860 thread_caches.append(middleware.cache)
2861
2862 for _ in range(2):
2863 thread = threading.Thread(target=runner)
2864 thread.start()
2865 thread.join()
2866
2867 self.assertIsNot(thread_caches[0], thread_caches[1])
2868
2869 def test_cache_control_max_age(self):
2870 view = cache_page(2)(hello_world_view)
2871 request = self.factory.get("/view/")
2872
2873 # First request. Freshly created response gets returned with no Age
2874 # header.
2875 with mock.patch.object(
2876 time, "time", return_value=1468749600
2877 ): # Sun, 17 Jul 2016 10:00:00 GMT
2878 response = view(request, 1)
2879 response.close()
2880 self.assertIn("Expires", response)
2881 self.assertEqual(response["Expires"], "Sun, 17 Jul 2016 10:00:02 GMT")
2882 self.assertIn("Cache-Control", response)
2883 self.assertEqual(response["Cache-Control"], "max-age=2")
2884 self.assertNotIn("Age", response)
2885
2886 # Second request one second later. Response from the cache gets
2887 # returned with an Age header set to 1 (second).
2888 with mock.patch.object(
2889 time, "time", return_value=1468749601
2890 ): # Sun, 17 Jul 2016 10:00:01 GMT
2891 response = view(request, 1)
2892 response.close()
2893 self.assertIn("Expires", response)
2894 self.assertEqual(response["Expires"], "Sun, 17 Jul 2016 10:00:02 GMT")
2895 self.assertIn("Cache-Control", response)
2896 self.assertEqual(response["Cache-Control"], "max-age=2")
2897 self.assertIn("Age", response)
2898 self.assertEqual(response["Age"], "1")
2899
2900
2901 @override_settings(
2902 CACHE_MIDDLEWARE_KEY_PREFIX="settingsprefix",
2903 CACHE_MIDDLEWARE_SECONDS=1,
2904 CACHES={
2905 "default": {
2906 "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
2907 },
2908 },
2909 USE_I18N=False,
2910 )
2911 class TestWithTemplateResponse(SimpleTestCase):
2912 """
2913 Tests various headers w/ TemplateResponse.
2914
2915 Most are probably redundant since they manipulate the same object
2916 anyway but the ETag header is 'special' because it relies on the
2917 content being complete (which is not necessarily always the case
2918 with a TemplateResponse)
2919 """
2920
2921 path = "/cache/test/"
2922 factory = RequestFactory()
2923
2924 def tearDown(self):
2925 cache.clear()
2926
2927 def test_patch_vary_headers(self):
2928 headers = (
2929 # Initial vary, new headers, resulting vary.
2930 (None, ("Accept-Encoding",), "Accept-Encoding"),
2931 ("Accept-Encoding", ("accept-encoding",), "Accept-Encoding"),
2932 ("Accept-Encoding", ("ACCEPT-ENCODING",), "Accept-Encoding"),
2933 ("Cookie", ("Accept-Encoding",), "Cookie, Accept-Encoding"),
2934 (
2935 "Cookie, Accept-Encoding",
2936 ("Accept-Encoding",),
2937 "Cookie, Accept-Encoding",
2938 ),
2939 (
2940 "Cookie, Accept-Encoding",
2941 ("Accept-Encoding", "cookie"),
2942 "Cookie, Accept-Encoding",
2943 ),
2944 (None, ("Accept-Encoding", "COOKIE"), "Accept-Encoding, COOKIE"),
2945 (
2946 "Cookie, Accept-Encoding",
2947 ("Accept-Encoding", "cookie"),
2948 "Cookie, Accept-Encoding",
2949 ),
2950 (
2951 "Cookie , Accept-Encoding",
2952 ("Accept-Encoding", "cookie"),
2953 "Cookie, Accept-Encoding",
2954 ),
2955 )
2956 for initial_vary, newheaders, resulting_vary in headers:
2957 with self.subTest(initial_vary=initial_vary, newheaders=newheaders):
2958 template = engines["django"].from_string("This is a test")
2959 response = TemplateResponse(HttpRequest(), template)
2960 if initial_vary is not None:
2961 response.headers["Vary"] = initial_vary
2962 patch_vary_headers(response, newheaders)
2963 self.assertEqual(response.headers["Vary"], resulting_vary)
2964
2965 def test_get_cache_key(self):
2966 request = self.factory.get(self.path)
2967 template = engines["django"].from_string("This is a test")
2968 response = TemplateResponse(HttpRequest(), template)
2969 key_prefix = "localprefix"
2970 # Expect None if no headers have been set yet.
2971 self.assertIsNone(get_cache_key(request))
2972 # Set headers to an empty list.
2973 learn_cache_key(request, response)
2974
2975 self.assertEqual(
2976 get_cache_key(request),
2977 "views.decorators.cache.cache_page.settingsprefix.GET."
2978 "58a0a05c8a5620f813686ff969c26853.d41d8cd98f00b204e9800998ecf8427e",
2979 )
2980 # A specified key_prefix is taken into account.
2981 learn_cache_key(request, response, key_prefix=key_prefix)
2982 self.assertEqual(
2983 get_cache_key(request, key_prefix=key_prefix),
2984 "views.decorators.cache.cache_page.localprefix.GET."
2985 "58a0a05c8a5620f813686ff969c26853.d41d8cd98f00b204e9800998ecf8427e",
2986 )
2987
2988 def test_get_cache_key_with_query(self):
2989 request = self.factory.get(self.path, {"test": 1})
2990 template = engines["django"].from_string("This is a test")
2991 response = TemplateResponse(HttpRequest(), template)
2992 # Expect None if no headers have been set yet.
2993 self.assertIsNone(get_cache_key(request))
2994 # Set headers to an empty list.
2995 learn_cache_key(request, response)
2996 # The querystring is taken into account.
2997 self.assertEqual(
2998 get_cache_key(request),
2999 "views.decorators.cache.cache_page.settingsprefix.GET."
3000 "0f1c2d56633c943073c4569d9a9502fe.d41d8cd98f00b204e9800998ecf8427e",
3001 )
3002
3003
3004 class TestMakeTemplateFragmentKey(SimpleTestCase):
3005 def test_without_vary_on(self):
3006 key = make_template_fragment_key("a.fragment")
3007 self.assertEqual(
3008 key, "template.cache.a.fragment.d41d8cd98f00b204e9800998ecf8427e"
3009 )
3010
3011 def test_with_one_vary_on(self):
3012 key = make_template_fragment_key("foo", ["abc"])
3013 self.assertEqual(key, "template.cache.foo.493e283d571a73056196f1a68efd0f66")
3014
3015 def test_with_many_vary_on(self):
3016 key = make_template_fragment_key("bar", ["abc", "def"])
3017 self.assertEqual(key, "template.cache.bar.17c1a507a0cb58384f4c639067a93520")
3018
3019 def test_proper_escaping(self):
3020 key = make_template_fragment_key("spam", ["abc:def%"])
3021 self.assertEqual(key, "template.cache.spam.06c8ae8e8c430b69fb0a6443504153dc")
3022
3023 def test_with_ints_vary_on(self):
3024 key = make_template_fragment_key("foo", [1, 2, 3, 4, 5])
3025 self.assertEqual(key, "template.cache.foo.7ae8fd2e0d25d651c683bdeebdb29461")
3026
3027 def test_with_unicode_vary_on(self):
3028 key = make_template_fragment_key("foo", ["42ยบ", "๐Ÿ˜€"])
3029 self.assertEqual(key, "template.cache.foo.7ced1c94e543668590ba39b3c08b0237")
3030
3031 def test_long_vary_on(self):
3032 key = make_template_fragment_key("foo", ["x" * 10000])
3033 self.assertEqual(key, "template.cache.foo.3670b349b5124aa56bdb50678b02b23a")
3034
3035
3036 class CacheHandlerTest(SimpleTestCase):
3037 def test_same_instance(self):
3038 """
3039 Attempting to retrieve the same alias should yield the same instance.
3040 """
3041 cache1 = caches["default"]
3042 cache2 = caches["default"]
3043
3044 self.assertIs(cache1, cache2)
3045
3046 def test_per_thread(self):
3047 """
3048 Requesting the same alias from separate threads should yield separate
3049 instances.
3050 """
3051 c = []
3052
3053 def runner():
3054 c.append(caches["default"])
3055
3056 for x in range(2):
3057 t = threading.Thread(target=runner)
3058 t.start()
3059 t.join()
3060
3061 self.assertIsNot(c[0], c[1])
3062
3063 def test_nonexistent_alias(self):
3064 msg = "The connection 'nonexistent' doesn't exist."
3065 with self.assertRaisesMessage(InvalidCacheBackendError, msg):
3066 caches["nonexistent"]
3067
3068 def test_nonexistent_backend(self):
3069 test_caches = CacheHandler(
3070 {
3071 "invalid_backend": {
3072 "BACKEND": "django.nonexistent.NonexistentBackend",
3073 },
3074 }
3075 )
3076 msg = (
3077 "Could not find backend 'django.nonexistent.NonexistentBackend': "
3078 "No module named 'django.nonexistent'"
3079 )
3080 with self.assertRaisesMessage(InvalidCacheBackendError, msg):
3081 test_caches["invalid_backend"]
3082
3083 def test_all(self):
3084 test_caches = CacheHandler(
3085 {
3086 "cache_1": {
3087 "BACKEND": "django.core.cache.backends.dummy.DummyCache",
3088 },
3089 "cache_2": {
3090 "BACKEND": "django.core.cache.backends.dummy.DummyCache",
3091 },
3092 }
3093 )
3094 self.assertEqual(test_caches.all(initialized_only=True), [])
3095 cache_1 = test_caches["cache_1"]
3096 self.assertEqual(test_caches.all(initialized_only=True), [cache_1])
3097 self.assertEqual(len(test_caches.all()), 2)
3098 # .all() initializes all caches.
3099 self.assertEqual(len(test_caches.all(initialized_only=True)), 2)
3100 self.assertEqual(test_caches.all(), test_caches.all(initialized_only=True))