Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-diskcache for
openSUSE:Factory checked in at 2022-01-17 22:33:52
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-diskcache (Old)
and /work/SRC/openSUSE:Factory/.python-diskcache.new.1892 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-diskcache"
Mon Jan 17 22:33:52 2022 rev:9 rq:946689 version:5.4.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-diskcache/python-diskcache.changes
2021-12-30 15:55:36.904663542 +0100
+++
/work/SRC/openSUSE:Factory/.python-diskcache.new.1892/python-diskcache.changes
2022-01-17 22:33:55.618239006 +0100
@@ -1,0 +2,9 @@
+Sat Jan 15 17:42:10 UTC 2022 - Dirk M??ller <[email protected]>
+
+- update to 5.4.0:
+ * test django 3.2
+ * Fix DjangoCache.delete to return True/False
+ * remove unused imports
+ * run isort
+
+-------------------------------------------------------------------
Old:
----
diskcache-5.3.0.tar.gz
New:
----
diskcache-5.4.0.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-diskcache.spec ++++++
--- /var/tmp/diff_new_pack.kv4X56/_old 2022-01-17 22:33:56.902239856 +0100
+++ /var/tmp/diff_new_pack.kv4X56/_new 2022-01-17 22:33:56.906239859 +0100
@@ -1,7 +1,7 @@
#
# spec file for package python-diskcache
#
-# Copyright (c) 2021 SUSE LLC
+# Copyright (c) 2022 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -19,7 +19,7 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
%global skip_python2 1
Name: python-diskcache
-Version: 5.3.0
+Version: 5.4.0
Release: 0
Summary: Disk and file backed cache
License: Apache-2.0
++++++ diskcache-5.3.0.tar.gz -> diskcache-5.4.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-diskcache-5.3.0/diskcache/__init__.py
new/python-diskcache-5.4.0/diskcache/__init__.py
--- old/python-diskcache-5.3.0/diskcache/__init__.py 2021-11-30
07:58:48.000000000 +0100
+++ new/python-diskcache-5.4.0/diskcache/__init__.py 2021-12-31
02:58:24.000000000 +0100
@@ -61,8 +61,8 @@
pass
__title__ = 'diskcache'
-__version__ = '5.3.0'
-__build__ = 0x050300
+__version__ = '5.4.0'
+__build__ = 0x050400
__author__ = 'Grant Jenks'
__license__ = 'Apache 2.0'
__copyright__ = 'Copyright 2016-2022 Grant Jenks'
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-diskcache-5.3.0/diskcache/djangocache.py
new/python-diskcache-5.4.0/diskcache/djangocache.py
--- old/python-diskcache-5.3.0/diskcache/djangocache.py 2021-11-30
07:58:48.000000000 +0100
+++ new/python-diskcache-5.4.0/diskcache/djangocache.py 2021-12-31
02:58:24.000000000 +0100
@@ -220,7 +220,7 @@
"""
# pylint: disable=arguments-differ
key = self.make_key(key, version=version)
- self._cache.delete(key, retry)
+ return self._cache.delete(key, retry)
def incr(self, key, delta=1, version=None, default=None, retry=True):
"""Increment value by delta for item with key.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-diskcache-5.3.0/requirements.txt
new/python-diskcache-5.4.0/requirements.txt
--- old/python-diskcache-5.3.0/requirements.txt 2021-11-30 07:58:48.000000000
+0100
+++ new/python-diskcache-5.4.0/requirements.txt 2021-12-31 02:58:24.000000000
+0100
@@ -1,7 +1,7 @@
-e .
blue
coverage
-django==2.2.*
+django==3.2.*
django_redis
doc8
flake8
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-diskcache-5.3.0/tests/test_djangocache.py
new/python-diskcache-5.4.0/tests/test_djangocache.py
--- old/python-diskcache-5.3.0/tests/test_djangocache.py 2021-11-30
07:58:48.000000000 +0100
+++ new/python-diskcache-5.4.0/tests/test_djangocache.py 2021-12-31
02:58:24.000000000 +0100
@@ -1,64 +1,24 @@
# Most of this file was copied from:
-#
https://raw.githubusercontent.com/django/django/stable/2.2.x/tests/cache/tests.py
+#
https://raw.githubusercontent.com/django/django/stable/3.2.x/tests/cache/tests.py
# Unit tests for cache framework
# Uses whatever cache backend is set in the test settings file.
-import copy
-import io
import os
import pickle
-import re
import shutil
import tempfile
-import threading
import time
-import unittest
-import warnings
from unittest import mock
from django.conf import settings
-from django.core import management, signals
-from django.core.cache import (
- DEFAULT_CACHE_ALIAS,
- CacheKeyWarning,
- InvalidCacheKey,
- cache,
- caches,
-)
-from django.core.cache.utils import make_template_fragment_key
-from django.db import close_old_connections, connection, connections
-from django.http import (
- HttpRequest,
- HttpResponse,
- HttpResponseNotModified,
- StreamingHttpResponse,
-)
+from django.core.cache import CacheKeyWarning, cache, caches
+from django.http import HttpResponse
from django.middleware.cache import (
- CacheMiddleware,
FetchFromCacheMiddleware,
UpdateCacheMiddleware,
)
-from django.middleware.csrf import CsrfViewMiddleware
-from django.template import engines
-from django.template.context_processors import csrf
-from django.template.response import TemplateResponse
-from django.test import (
- RequestFactory,
- SimpleTestCase,
- TestCase,
- TransactionTestCase,
- override_settings,
-)
+from django.test import RequestFactory, TestCase, override_settings
from django.test.signals import setting_changed
-from django.utils import timezone, translation
-from django.utils.cache import (
- get_cache_key,
- learn_cache_key,
- patch_cache_control,
- patch_vary_headers,
-)
-from django.utils.encoding import force_text
-from django.views.decorators.cache import cache_page
################################################################################
# Setup Django for models import.
@@ -88,6 +48,10 @@
raise pickle.PickleError()
+def empty_response(request):
+ return HttpResponse()
+
+
KEY_ERRORS_WITH_MEMCACHED_MSG = (
'Cache key contains characters that will cause errors if used with '
'memcached: %r'
@@ -138,6 +102,14 @@
# A common set of tests to apply to all cache backends
factory = RequestFactory()
+ # RemovedInDjango41Warning: python-memcached doesn't support .get() with
+ # default.
+ supports_get_with_default = True
+
+ # Some clients raise custom exceptions when .incr() or .decr() are called
+ # with a non-integer value.
+ incr_decr_type_error = TypeError
+
def tearDown(self):
cache.clear()
@@ -146,11 +118,15 @@
cache.set('key', 'value')
self.assertEqual(cache.get('key'), 'value')
+ def test_default_used_when_none_is_set(self):
+ """If None is cached, get() returns it instead of the default."""
+ cache.set('key_default_none', None)
+ self.assertIsNone(cache.get('key_default_none', default='default'))
+
def test_add(self):
# A key can be added to a cache
- cache.add('addkey1', 'value')
- result = cache.add('addkey1', 'newvalue')
- self.assertFalse(result)
+ self.assertIs(cache.add('addkey1', 'value'), True)
+ self.assertIs(cache.add('addkey1', 'newvalue'), False)
self.assertEqual(cache.get('addkey1'), 'value')
def test_prefix(self):
@@ -158,7 +134,7 @@
cache.set('somekey', 'value')
# should not be set in the prefixed cache
- self.assertFalse(caches['prefix'].has_key('somekey'))
+ self.assertIs(caches['prefix'].has_key('somekey'), False)
caches['prefix'].set('somekey', 'value2')
@@ -180,28 +156,43 @@
self.assertEqual(
cache.get_many(iter(['a', 'b', 'e'])), {'a': 'a', 'b': 'b'}
)
+ cache.set_many({'x': None, 'y': 1})
+ self.assertEqual(cache.get_many(['x', 'y']), {'x': None, 'y': 1})
def test_delete(self):
# Cache keys can be deleted
cache.set_many({'key1': 'spam', 'key2': 'eggs'})
self.assertEqual(cache.get('key1'), 'spam')
- cache.delete('key1')
+ self.assertIs(cache.delete('key1'), True)
self.assertIsNone(cache.get('key1'))
self.assertEqual(cache.get('key2'), 'eggs')
+ def test_delete_nonexistent(self):
+ self.assertIs(cache.delete('nonexistent_key'), False)
+
def test_has_key(self):
# The cache can be inspected for cache keys
cache.set('hello1', 'goodbye1')
- self.assertTrue(cache.has_key('hello1'))
- self.assertFalse(cache.has_key('goodbye1'))
+ self.assertIs(cache.has_key('hello1'), True)
+ self.assertIs(cache.has_key('goodbye1'), False)
cache.set('no_expiry', 'here', None)
- self.assertTrue(cache.has_key('no_expiry'))
+ self.assertIs(cache.has_key('no_expiry'), True)
+ cache.set('null', None)
+ self.assertIs(
+ cache.has_key('null'),
+ True if self.supports_get_with_default else False,
+ )
def test_in(self):
# The in operator can be used to inspect cache contents
cache.set('hello2', 'goodbye2')
self.assertIn('hello2', cache)
self.assertNotIn('goodbye2', cache)
+ cache.set('null', None)
+ if self.supports_get_with_default:
+ self.assertIn('null', cache)
+ else:
+ self.assertNotIn('null', cache)
def test_incr(self):
# Cache values can be incremented
@@ -213,6 +204,9 @@
self.assertEqual(cache.incr('answer', -10), 42)
with self.assertRaises(ValueError):
cache.incr('does_not_exist')
+ cache.set('null', None)
+ with self.assertRaises(self.incr_decr_type_error):
+ cache.incr('null')
def test_decr(self):
# Cache values can be decremented
@@ -224,6 +218,9 @@
self.assertEqual(cache.decr('answer', -10), 42)
with self.assertRaises(ValueError):
cache.decr('does_not_exist')
+ cache.set('null', None)
+ with self.assertRaises(self.incr_decr_type_error):
+ cache.decr('null')
def test_close(self):
self.assertTrue(hasattr(cache, 'close'))
@@ -295,24 +292,23 @@
time.sleep(2)
self.assertIsNone(cache.get('expire1'))
- cache.add('expire2', 'newvalue')
+ self.assertIs(cache.add('expire2', 'newvalue'), True)
self.assertEqual(cache.get('expire2'), 'newvalue')
- self.assertFalse(cache.has_key('expire3'))
+ self.assertIs(cache.has_key('expire3'), False)
def test_touch(self):
# cache.touch() updates the timeout.
cache.set('expire1', 'very quickly', timeout=1)
self.assertIs(cache.touch('expire1', timeout=4), True)
time.sleep(2)
- self.assertTrue(cache.has_key('expire1'))
+ self.assertIs(cache.has_key('expire1'), True)
time.sleep(3)
- self.assertFalse(cache.has_key('expire1'))
-
+ self.assertIs(cache.has_key('expire1'), False)
# cache.touch() works without the timeout argument.
cache.set('expire1', 'very quickly', timeout=1)
self.assertIs(cache.touch('expire1'), True)
time.sleep(2)
- self.assertTrue(cache.has_key('expire1'))
+ self.assertIs(cache.has_key('expire1'), True)
self.assertIs(cache.touch('nonexistent'), False)
@@ -333,13 +329,13 @@
# Test `add`
for (key, value) in stuff.items():
with self.subTest(key=key):
- cache.delete(key)
- cache.add(key, value)
+ self.assertIs(cache.delete(key), True)
+ self.assertIs(cache.add(key, value), True)
self.assertEqual(cache.get(key), value)
# Test `set_many`
for (key, value) in stuff.items():
- cache.delete(key)
+ self.assertIs(cache.delete(key), True)
cache.set_many(stuff)
for (key, value) in stuff.items():
with self.subTest(key=key):
@@ -359,7 +355,7 @@
self.assertEqual(value, decompress(compressed_result).decode())
# Test add
- cache.add('binary1-add', compressed_value)
+ self.assertIs(cache.add('binary1-add', compressed_value), True)
compressed_result = cache.get('binary1-add')
self.assertEqual(compressed_value, compressed_result)
self.assertEqual(value, decompress(compressed_result).decode())
@@ -405,14 +401,14 @@
def test_long_timeout(self):
"""
- Followe memcached's convention where a timeout greater than 30 days is
+ Follow memcached's convention where a timeout greater than 30 days is
treated as an absolute expiration timestamp instead of a relative
offset (#12399).
"""
cache.set('key1', 'eggs', 60 * 60 * 24 * 30 + 1) # 30 days + 1 second
self.assertEqual(cache.get('key1'), 'eggs')
- cache.add('key2', 'ham', 60 * 60 * 24 * 30 + 1)
+ self.assertIs(cache.add('key2', 'ham', 60 * 60 * 24 * 30 + 1), True)
self.assertEqual(cache.get('key2'), 'ham')
cache.set_many(
@@ -429,10 +425,9 @@
cache.set('key1', 'eggs', None)
self.assertEqual(cache.get('key1'), 'eggs')
- cache.add('key2', 'ham', None)
+ self.assertIs(cache.add('key2', 'ham', None), True)
self.assertEqual(cache.get('key2'), 'ham')
- added = cache.add('key1', 'new eggs', None)
- self.assertIs(added, False)
+ self.assertIs(cache.add('key1', 'new eggs', None), False)
self.assertEqual(cache.get('key1'), 'eggs')
cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, None)
@@ -440,7 +435,7 @@
self.assertEqual(cache.get('key4'), 'lobster bisque')
cache.set('key5', 'belgian fries', timeout=1)
- cache.touch('key5', timeout=None)
+ self.assertIs(cache.touch('key5', timeout=None), True)
time.sleep(2)
self.assertEqual(cache.get('key5'), 'belgian fries')
@@ -451,7 +446,7 @@
cache.set('key1', 'eggs', 0)
self.assertIsNone(cache.get('key1'))
- cache.add('key2', 'ham', 0)
+ self.assertIs(cache.add('key2', 'ham', 0), True)
self.assertIsNone(cache.get('key2'))
cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, 0)
@@ -459,7 +454,7 @@
self.assertIsNone(cache.get('key4'))
cache.set('key5', 'belgian fries', timeout=5)
- cache.touch('key5', timeout=0)
+ self.assertIs(cache.touch('key5', timeout=0), True)
self.assertIsNone(cache.get('key5'))
def test_float_timeout(self):
@@ -467,7 +462,12 @@
cache.set('key1', 'spam', 100.2)
self.assertEqual(cache.get('key1'), 'spam')
- def _perform_cull_test(self, cull_cache, initial_count, final_count):
+ def _perform_cull_test(self, cull_cache_name, initial_count, final_count):
+ try:
+ cull_cache = caches[cull_cache_name]
+ except InvalidCacheBackendError:
+ self.skipTest("Culling isn't implemented.")
+
# Create initial cache key entries. This will overflow the cache,
# causing a cull.
for i in range(1, initial_count):
@@ -480,10 +480,24 @@
self.assertEqual(count, final_count)
def test_cull(self):
- self._perform_cull_test(caches['cull'], 50, 29)
+ self._perform_cull_test('cull', 50, 29)
def test_zero_cull(self):
- self._perform_cull_test(caches['zero_cull'], 50, 19)
+ self._perform_cull_test('zero_cull', 50, 19)
+
+ def test_cull_delete_when_store_empty(self):
+ try:
+ cull_cache = caches['cull']
+ except InvalidCacheBackendError:
+ self.skipTest("Culling isn't implemented.")
+ old_max_entries = cull_cache._max_entries
+ # Force _cull to delete on first cached record.
+ cull_cache._max_entries = -1
+ try:
+ cull_cache.set('force_cull_delete', 'value', 1000)
+ self.assertIs(cull_cache.has_key('force_cull_delete'), True)
+ finally:
+ cull_cache._max_entries = old_max_entries
def _perform_invalid_key_test(self, key, expected_warning):
"""
@@ -500,10 +514,24 @@
old_func = cache.key_func
cache.key_func = func
+ tests = [
+ ('add', [key, 1]),
+ ('get', [key]),
+ ('set', [key, 1]),
+ ('incr', [key]),
+ ('decr', [key]),
+ ('touch', [key]),
+ ('delete', [key]),
+ ('get_many', [[key, 'b']]),
+ ('set_many', [{key: 1, 'b': 2}]),
+ ('delete_many', [{key: 1, 'b': 2}]),
+ ]
try:
- with self.assertWarns(CacheKeyWarning) as cm:
- cache.set(key, 'value')
- self.assertEqual(str(cm.warning), expected_warning)
+ for operation, args in tests:
+ with self.subTest(operation=operation):
+ with self.assertWarns(CacheKeyWarning) as cm:
+ getattr(cache, operation)(*args)
+ self.assertEqual(str(cm.warning), expected_warning)
finally:
cache.key_func = old_func
@@ -567,41 +595,41 @@
def test_cache_versioning_add(self):
# add, default version = 1, but manually override version = 2
- cache.add('answer1', 42, version=2)
+ self.assertIs(cache.add('answer1', 42, version=2), True)
self.assertIsNone(cache.get('answer1', version=1))
self.assertEqual(cache.get('answer1', version=2), 42)
- cache.add('answer1', 37, version=2)
+ self.assertIs(cache.add('answer1', 37, version=2), False)
self.assertIsNone(cache.get('answer1', version=1))
self.assertEqual(cache.get('answer1', version=2), 42)
- cache.add('answer1', 37, version=1)
+ self.assertIs(cache.add('answer1', 37, version=1), True)
self.assertEqual(cache.get('answer1', version=1), 37)
self.assertEqual(cache.get('answer1', version=2), 42)
# v2 add, using default version = 2
- caches['v2'].add('answer2', 42)
+ self.assertIs(caches['v2'].add('answer2', 42), True)
self.assertIsNone(cache.get('answer2', version=1))
self.assertEqual(cache.get('answer2', version=2), 42)
- caches['v2'].add('answer2', 37)
+ self.assertIs(caches['v2'].add('answer2', 37), False)
self.assertIsNone(cache.get('answer2', version=1))
self.assertEqual(cache.get('answer2', version=2), 42)
- caches['v2'].add('answer2', 37, version=1)
+ self.assertIs(caches['v2'].add('answer2', 37, version=1), True)
self.assertEqual(cache.get('answer2', version=1), 37)
self.assertEqual(cache.get('answer2', version=2), 42)
# v2 add, default version = 2, but manually override version = 1
- caches['v2'].add('answer3', 42, version=1)
+ self.assertIs(caches['v2'].add('answer3', 42, version=1), True)
self.assertEqual(cache.get('answer3', version=1), 42)
self.assertIsNone(cache.get('answer3', version=2))
- caches['v2'].add('answer3', 37, version=1)
+ self.assertIs(caches['v2'].add('answer3', 37, version=1), False)
self.assertEqual(cache.get('answer3', version=1), 42)
self.assertIsNone(cache.get('answer3', version=2))
- caches['v2'].add('answer3', 37)
+ self.assertIs(caches['v2'].add('answer3', 37), True)
self.assertEqual(cache.get('answer3', version=1), 42)
self.assertEqual(cache.get('answer3', version=2), 37)
@@ -609,73 +637,73 @@
cache.set('answer1', 42)
# has_key
- self.assertTrue(cache.has_key('answer1'))
- self.assertTrue(cache.has_key('answer1', version=1))
- self.assertFalse(cache.has_key('answer1', version=2))
-
- self.assertFalse(caches['v2'].has_key('answer1'))
- self.assertTrue(caches['v2'].has_key('answer1', version=1))
- self.assertFalse(caches['v2'].has_key('answer1', version=2))
+ self.assertIs(cache.has_key('answer1'), True)
+ self.assertIs(cache.has_key('answer1', version=1), True)
+ self.assertIs(cache.has_key('answer1', version=2), False)
+
+ self.assertIs(caches['v2'].has_key('answer1'), False)
+ self.assertIs(caches['v2'].has_key('answer1', version=1), True)
+ self.assertIs(caches['v2'].has_key('answer1', version=2), False)
def test_cache_versioning_delete(self):
cache.set('answer1', 37, version=1)
cache.set('answer1', 42, version=2)
- cache.delete('answer1')
+ self.assertIs(cache.delete('answer1'), True)
self.assertIsNone(cache.get('answer1', version=1))
self.assertEqual(cache.get('answer1', version=2), 42)
cache.set('answer2', 37, version=1)
cache.set('answer2', 42, version=2)
- cache.delete('answer2', version=2)
+ self.assertIs(cache.delete('answer2', version=2), True)
self.assertEqual(cache.get('answer2', version=1), 37)
self.assertIsNone(cache.get('answer2', version=2))
cache.set('answer3', 37, version=1)
cache.set('answer3', 42, version=2)
- caches['v2'].delete('answer3')
+ self.assertIs(caches['v2'].delete('answer3'), True)
self.assertEqual(cache.get('answer3', version=1), 37)
self.assertIsNone(cache.get('answer3', version=2))
cache.set('answer4', 37, version=1)
cache.set('answer4', 42, version=2)
- caches['v2'].delete('answer4', version=1)
+ self.assertIs(caches['v2'].delete('answer4', version=1), True)
self.assertIsNone(cache.get('answer4', version=1))
self.assertEqual(cache.get('answer4', version=2), 42)
def test_cache_versioning_incr_decr(self):
cache.set('answer1', 37, version=1)
cache.set('answer1', 42, version=2)
- cache.incr('answer1')
+ self.assertEqual(cache.incr('answer1'), 38)
self.assertEqual(cache.get('answer1', version=1), 38)
self.assertEqual(cache.get('answer1', version=2), 42)
- cache.decr('answer1')
+ self.assertEqual(cache.decr('answer1'), 37)
self.assertEqual(cache.get('answer1', version=1), 37)
self.assertEqual(cache.get('answer1', version=2), 42)
cache.set('answer2', 37, version=1)
cache.set('answer2', 42, version=2)
- cache.incr('answer2', version=2)
+ self.assertEqual(cache.incr('answer2', version=2), 43)
self.assertEqual(cache.get('answer2', version=1), 37)
self.assertEqual(cache.get('answer2', version=2), 43)
- cache.decr('answer2', version=2)
+ self.assertEqual(cache.decr('answer2', version=2), 42)
self.assertEqual(cache.get('answer2', version=1), 37)
self.assertEqual(cache.get('answer2', version=2), 42)
cache.set('answer3', 37, version=1)
cache.set('answer3', 42, version=2)
- caches['v2'].incr('answer3')
+ self.assertEqual(caches['v2'].incr('answer3'), 43)
self.assertEqual(cache.get('answer3', version=1), 37)
self.assertEqual(cache.get('answer3', version=2), 43)
- caches['v2'].decr('answer3')
+ self.assertEqual(caches['v2'].decr('answer3'), 42)
self.assertEqual(cache.get('answer3', version=1), 37)
self.assertEqual(cache.get('answer3', version=2), 42)
cache.set('answer4', 37, version=1)
cache.set('answer4', 42, version=2)
- caches['v2'].incr('answer4', version=1)
+ self.assertEqual(caches['v2'].incr('answer4', version=1), 38)
self.assertEqual(cache.get('answer4', version=1), 38)
self.assertEqual(cache.get('answer4', version=2), 42)
- caches['v2'].decr('answer4', version=1)
+ self.assertEqual(caches['v2'].decr('answer4', version=1), 37)
self.assertEqual(cache.get('answer4', version=1), 37)
self.assertEqual(cache.get('answer4', version=2), 42)
@@ -790,6 +818,13 @@
with self.assertRaises(ValueError):
cache.incr_version('does_not_exist')
+ cache.set('null', None)
+ if self.supports_get_with_default:
+ self.assertEqual(cache.incr_version('null'), 2)
+ else:
+ with self.assertRaises(self.incr_decr_type_error):
+ cache.incr_version('null')
+
def test_decr_version(self):
cache.set('answer', 42, version=2)
self.assertIsNone(cache.get('answer'))
@@ -814,6 +849,13 @@
with self.assertRaises(ValueError):
cache.decr_version('does_not_exist', version=2)
+ cache.set('null', None, version=2)
+ if self.supports_get_with_default:
+ self.assertEqual(cache.decr_version('null', version=2), 1)
+ else:
+ with self.assertRaises(self.incr_decr_type_error):
+ cache.decr_version('null', version=2)
+
def test_custom_key_func(self):
# Two caches with different key functions aren't visible to each other
cache.set('answer1', 42)
@@ -827,30 +869,33 @@
self.assertEqual(caches['custom_key2'].get('answer2'), 42)
def test_cache_write_unpicklable_object(self):
- update_middleware = UpdateCacheMiddleware()
- update_middleware.cache = cache
-
- fetch_middleware = FetchFromCacheMiddleware()
+ fetch_middleware = FetchFromCacheMiddleware(empty_response)
fetch_middleware.cache = cache
request = self.factory.get('/cache/test')
request._cache_update_cache = True
- get_cache_data = FetchFromCacheMiddleware().process_request(request)
+ get_cache_data = FetchFromCacheMiddleware(
+ empty_response
+ ).process_request(request)
self.assertIsNone(get_cache_data)
- response = HttpResponse()
content = 'Testing cookie serialization.'
- response.content = content
- response.set_cookie('foo', 'bar')
- update_middleware.process_response(request, response)
+ def get_response(req):
+ response = HttpResponse(content)
+ response.set_cookie('foo', 'bar')
+ return response
+
+ update_middleware = UpdateCacheMiddleware(get_response)
+ update_middleware.cache = cache
+ response = update_middleware(request)
get_cache_data = fetch_middleware.process_request(request)
self.assertIsNotNone(get_cache_data)
self.assertEqual(get_cache_data.content, content.encode())
self.assertEqual(get_cache_data.cookies, response.cookies)
- update_middleware.process_response(request, get_cache_data)
+ UpdateCacheMiddleware(lambda req: get_cache_data)(request)
get_cache_data = fetch_middleware.process_request(request)
self.assertIsNotNone(get_cache_data)
self.assertEqual(get_cache_data.content, content.encode())
@@ -869,7 +914,12 @@
self.assertIsNone(cache.get('projector'))
self.assertEqual(cache.get_or_set('projector', 42), 42)
self.assertEqual(cache.get('projector'), 42)
- self.assertEqual(cache.get_or_set('null', None), None)
+ self.assertIsNone(cache.get_or_set('null', None))
+ if self.supports_get_with_default:
+ # Previous get_or_set() stores None in the cache.
+ self.assertIsNone(cache.get('null', 'default'))
+ else:
+ self.assertEqual(cache.get('null', 'default'), 'default')
def test_get_or_set_callable(self):
def my_callable():
@@ -878,14 +928,16 @@
self.assertEqual(cache.get_or_set('mykey', my_callable), 'value')
self.assertEqual(cache.get_or_set('mykey', my_callable()), 'value')
- def test_get_or_set_callable_returning_none(self):
- self.assertIsNone(cache.get_or_set('mykey', lambda: None))
- # Previous get_or_set() doesn't store None in the cache.
- self.assertEqual(cache.get('mykey', 'default'), 'default')
+ self.assertIsNone(cache.get_or_set('null', lambda: None))
+ if self.supports_get_with_default:
+ # Previous get_or_set() stores None in the cache.
+ self.assertIsNone(cache.get('null', 'default'))
+ else:
+ self.assertEqual(cache.get('null', 'default'), 'default')
def test_get_or_set_version(self):
msg = "get_or_set() missing 1 required positional argument: 'default'"
- cache.get_or_set('brian', 1979, version=2)
+ self.assertEqual(cache.get_or_set('brian', 1979, version=2), 1979)
with self.assertRaisesMessage(TypeError, msg):
cache.get_or_set('brian')
with self.assertRaisesMessage(TypeError, msg):
@@ -949,6 +1001,11 @@
)
os.remove(fname)
+ def test_creates_cache_dir_if_nonexistent(self):
+ os.rmdir(self.dirname)
+ cache.set('foo', 'bar')
+ self.assertTrue(os.path.exists(self.dirname))
+
def test_clear_does_not_remove_cache_dir(self):
cache.clear()
self.assertTrue(
@@ -1026,19 +1083,6 @@
)
self.assertEqual(cache.pop(4, retry=False), 4)
- def test_pickle(self):
- letters = 'abcde'
- cache.clear()
-
- for num, val in enumerate(letters):
- cache.set(val, num)
-
- data = pickle.dumps(cache)
- other = pickle.loads(data)
-
- for key in letters:
- self.assertEqual(other.get(key), cache.get(key))
-
def test_cache(self):
subcache = cache.cache('test')
directory = os.path.join(cache.directory, 'cache', 'test')
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-diskcache-5.3.0/tox.ini
new/python-diskcache-5.4.0/tox.ini
--- old/python-diskcache-5.3.0/tox.ini 2021-11-30 07:58:48.000000000 +0100
+++ new/python-diskcache-5.4.0/tox.ini 2021-12-31 02:58:24.000000000 +0100
@@ -5,7 +5,7 @@
[testenv]
commands=pytest
deps=
- django==2.2.*
+ django==3.2.*
pytest
pytest-cov
pytest-django
@@ -31,7 +31,7 @@
changedir=docs
commands=make html
deps=
- django==2.2.*
+ django==3.2.*
sphinx
[testenv:flake8]
@@ -53,7 +53,7 @@
[testenv:pylint]
commands=pylint {toxinidir}/diskcache
deps=
- django==2.2.*
+ django==3.2.*
pylint
[testenv:rstcheck]
