Add incr/decr support #6, use pytest and tox #5 (#7)

Author: Kub-AT

cache_fallback/cache.py

@@ -14,18 +14,18 @@ def get_cache(backend, **kwargs):
     from django.core import cache as dj_cache
 
     if django.VERSION <= (1, 6):
-        cache = dj_cache.get_cache(backend, **kwargs)
+        cache_instance = dj_cache.get_cache(backend, **kwargs)
     elif django.VERSION >= (3, 2):
-        cache = dj_cache.caches.create_connection(backend)
+        cache_instance = dj_cache.caches.create_connection(backend)
     else:  # Django 1.7 to 3.1
-        cache = dj_cache._create_cache(backend, **kwargs)
+        cache_instance = dj_cache._create_cache(backend, **kwargs)
 
     # Some caches -- python-memcached in particular -- need to do a cleanup at the
     # end of a request cycle. If not implemented in a particular backend
     # cache.close is a no-op. Not available in Django 1.5
-    if hasattr(cache, "close"):
-        signals.request_finished.connect(cache.close)
-    return cache
+    if hasattr(cache_instance, "close"):
+        signals.request_finished.connect(cache_instance.close)
+    return cache_instance
 
 
 class FallbackCache(BaseCache):
@@ -38,34 +38,36 @@ def __init__(self, params=None, *args, **kwargs):
         self._cache_fallback = get_cache("fallback_cache")
 
     def add(self, key, value, timeout=None, version=None):
-        return self._call_with_fallback(
-            "add", key, value, timeout=timeout, version=version
-        )
+        return self._call_with_fallback("add", key, value, timeout=timeout, version=version)
 
     def get(self, key, default=None, version=None):
         return self._call_with_fallback("get", key, default=default, version=version)
 
     def set(self, key, value, timeout=None, version=None, client=None):
-        return self._call_with_fallback(
-            "set", key, value, timeout=timeout, version=version
-        )
+        return self._call_with_fallback("set", key, value, timeout=timeout, version=version)
 
     def delete(self, key, version=None):
         return self._call_with_fallback("delete", key, version=version)
 
     def clear(self):
         return self._call_with_fallback("clear")
 
+    def incr(self, key, delta=1, version=None):
+        return self._call_with_fallback("incr", key, delta=delta, version=version)
+
+    def decr(self, key, delta=1, version=None):
+        return self._call_with_fallback("decr", key, delta=delta, version=version)
+
     def _call_with_fallback(self, method, *args, **kwargs):
         try:
-            return self._call_main_cache(args, kwargs, method)
+            return self._call_main_cache(method, *args, **kwargs)
         except Exception as e:
             logger.warning("Switch to fallback cache")
             logger.exception(e)
-            return self._call_fallback_cache(args, kwargs, method)
+            return self._call_fallback_cache(method, *args, **kwargs)
 
-    def _call_main_cache(self, args, kwargs, method):
+    def _call_main_cache(self, method, *args, **kwargs):
         return getattr(self._cache, method)(*args, **kwargs)
 
-    def _call_fallback_cache(self, args, kwargs, method):
-        return getattr(self._cache_fallback, method)(*args, **kwargs)
+    def _call_fallback_cache(self, method, *args, **kwargs):
+        return getattr(self._cache_fallback, method)(*args, **kwargs)

runtests.py

@@ -1 +1 @@
-# just run: python setup.py test
+# just run: tox

setup.cfg

@@ -2,8 +2,8 @@
 universal = 1
 
 [tool:pytest]
+DJANGO_SETTINGS_MODULE = tests.settings
 norecursedirs = .git .eggs
-addopts = --cov=cache_fallback --cov-report term-missing
 
 [testenv:flake8]
 commands = flake8
@@ -12,6 +12,12 @@ commands = flake8
 branch = True
 omit = tests/*
 
+[coverage:report]
+precision = 2
+show_missing = True
+skip_covered = True
+skip_empty = True
+
 [flake8]
 ignore = E721,E203,W503
 max-line-length = 120

setup.py

@@ -1,79 +1,42 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 import io
-import sys
 from setuptools import setup, find_packages
-from setuptools.command.test import test as TestCommand
 
+with io.open("requirements.txt", encoding="utf-8") as f:
+    requirements = [line.strip() for line in f if line.strip()]
 
-with open("requirements.txt") as f:
-    requirements = [line.strip() for line in f.readlines()]
-
-
-class PyTest(TestCommand):
-    user_options = [("pytest-args=", "a", "Arguments to pass to py.test")]
-
-    def initialize_options(self):
-        TestCommand.initialize_options(self)
-        self.pytest_args = []
-
-    def finalize_options(self):
-        TestCommand.finalize_options(self)
-        self.test_args = []
-        self.test_suite = True
-
-    def run_tests(self):
-        import pytest
-        import django
-        from django.conf import settings
-
-        settings.configure(
-            TESTING=True,
-            DATABASES={
-                "default": {"ENGINE": "django.db.backends.sqlite3", "NAME": "test.db"},
-            },
-            CACHES={
-                "default": {"BACKEND": "cache_fallback.FallbackCache"},
-                "fallback_cache": {
-                    "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
-                    "LOCATION": "unique",
-                },
-                "main_cache": {
-                    "BACKEND": "django.core.cache.backends.dummy.DummyCache",
-                },
-            },
-            INSTALLED_APPS=(
-                "django.contrib.auth",
-                "django.contrib.contenttypes",
-                "django.contrib.sessions",
-                "cache_fallback",
-                "tests.testapp",
-            ),
-            MIDDLEWARE_CLASSES=("django.middleware.common.CommonMiddleware",),
-        )
-
-        if django.VERSION[:2] >= (1, 7):
-            django.setup()
-
-        errno = pytest.main(self.pytest_args)
-        sys.exit(errno)
-
+with io.open("README.rst", encoding="utf-8") as f:
+    long_description = f.read()
 
 setup(
     name="django-cache-fallback",
-    version="0.3.0",
+    version="0.4.0",
     description="Django Cache Fallback",
-    keywords="django-cache-fallback, django cache, multiple cache, fallback cache",
+    long_description=long_description,
+    long_description_content_type="text/x-rst",
     author="Jakub Stawowy",
     author_email="[email protected]",
     url="https://github.com/Kub-AT/django-cache-fallback",
     license="3-clause BSD",
-    long_description=io.open("./README.rst", "r", encoding="utf-8").read(),
     platforms="any",
     zip_safe=False,
+    packages=find_packages(exclude=("tests",)),
+    include_package_data=True,
+    install_requires=requirements,
+    extras_require={
+        "tests": [
+            "pytest",
+            "coverage",
+            "pytest-cov",
+            "flake8",
+            "python-memcached",
+            "mock",
+            "django",
+        ]
+    },
     classifiers=[
         "Programming Language :: Python",
-        "Programming Language :: Python :: 2",
         "Programming Language :: Python :: 2.7",
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.4",
@@ -82,30 +45,12 @@ def run_tests(self):
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "Development Status :: 5 - Production/Stable",
         "Environment :: Web Environment",
         "Framework :: Django",
-        "Framework :: Django :: 3.2",
-        "Framework :: Django :: 3.2",
-        "Framework :: Django :: 3.1",
-        "Framework :: Django :: 2.2",
-        "Framework :: Django :: 1.11",
-        "Framework :: Django :: 1.10",
-        "Framework :: Django :: 1.9",
-        "Framework :: Django :: 1.8",
-        "Intended Audience :: Developers",
-    ],
-    packages=find_packages(exclude=("tests",)),
-    include_package_data=True,
-    install_requires=requirements,
-    tests_require=[
-        "flake8",
-        "pytest",
-        "coverage",
-        "pytest-cov",
-        "python-memcached",
-        "mock",
     ],
-    setup_requires=["pytest-runner"],
-    cmdclass={"test": PyTest},
-)
+    setup_requires=["tox"],
+)

tests/settings.py

@@ -0,0 +1,37 @@
+import os
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+SECRET_KEY = "test-secret-key"
+DEBUG = True
+USE_TZ = False
+
+INSTALLED_APPS = [
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "cache_fallback",
+    "tests.testapp",
+]
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": ":memory:",
+    }
+}
+
+CACHES = {
+    "default": {"BACKEND": "cache_fallback.FallbackCache"},
+    "fallback_cache": {
+        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+        "LOCATION": "unique",
+    },
+    "main_cache": {
+        "BACKEND": "django.core.cache.backends.dummy.DummyCache",
+    },
+}
+
+MIDDLEWARE = [
+    "django.middleware.common.CommonMiddleware",
+]

tests/test_basic.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-from mock import patch
+from unittest.mock import patch
 
 from django.core.cache import BaseCache
 from django import test
@@ -12,81 +12,67 @@ def get_client(**kwargs):
 
 
 class CacheFallbackBasicTestCase(test.TestCase):
+    def setUp(self):
+        self._sut = get_client()
+
     def test_client(self):
-        client = get_client()
-        self.assertIsInstance(client, FallbackCache)
-        self.assertIsInstance(client._cache, BaseCache)
-        self.assertIsInstance(client._cache_fallback, BaseCache)
+        self.assertIsInstance(self._sut, FallbackCache)
+        self.assertIsInstance(self._sut._cache, BaseCache)
+        self.assertIsInstance(self._sut._cache_fallback, BaseCache)
 
     @patch.object(FallbackCache, "_call_fallback_cache")
     @patch.object(FallbackCache, "_call_main_cache")
     def test_get_maincache(self, maincache_mock, fallback_cache_mock):
-        client = get_client()
-        client.get("irrelevent")
-
+        self._sut.get("irrelevent")
         maincache_mock.assert_called_once()
         fallback_cache_mock.assert_not_called()
 
     @patch.object(FallbackCache, "_call_fallback_cache")
     @patch.object(FallbackCache, "_call_main_cache")
     def test_set_maincache(self, maincache_mock, fallback_cache_mock):
-        client = get_client()
-        client.set("irrelevent", "123", 5)
-
+        self._sut.set("irrelevent", "123", 5)
         maincache_mock.assert_called_once()
         fallback_cache_mock.assert_not_called()
 
     @patch.object(FallbackCache, "_call_fallback_cache")
     @patch.object(FallbackCache, "_call_main_cache")
     def test_get_fallbackcache(self, maincache_mock, fallback_cache_mock):
-        client = get_client()
-        client.get("irrelevent")
-
+        self._sut.get("irrelevent")
         maincache_mock.assert_called_once()
         fallback_cache_mock.assert_not_called()
 
         maincache_mock.side_effect = Exception()
-        client.get("irrelevent")
-
+        self._sut.get("irrelevent")
         fallback_cache_mock.assert_called_once()
 
     @patch.object(FallbackCache, "_call_fallback_cache")
     @patch.object(FallbackCache, "_call_main_cache")
     def test_multiple_get_fallbackcache(self, maincache_mock, fallback_cache_mock):
-        client = get_client()
-        client.get("irrelevent")
-
+        self._sut.get("irrelevent")
         maincache_mock.assert_called_once()
         fallback_cache_mock.assert_not_called()
 
         maincache_mock.side_effect = Exception()
-        to_get = ["irrelevent1", "irrelevent2", "irrelevent3"]
-        for key in to_get:
-            client.get(key)
-
-        fallback_cache_mock.assert_called()
-        self.assertEqual(fallback_cache_mock.call_count, len(to_get))
+        keys = ["irrelevent1", "irrelevent2", "irrelevent3"]
+        for key in keys:
+            self._sut.get(key)
+        self.assertEqual(fallback_cache_mock.call_count, len(keys))
 
     @patch.object(FallbackCache, "_call_fallback_cache")
     @patch.object(FallbackCache, "_call_main_cache")
     def test_set_fallbackcache(self, maincache_mock, fallback_cache_mock):
-        client = get_client()
-        client.set("irrelevent", "123", 5)
-
+        self._sut.set("irrelevent", "123", 5)
         maincache_mock.assert_called_once()
         fallback_cache_mock.assert_not_called()
 
         maincache_mock.side_effect = Exception()
-        client.set("irrelevent", "123", 5)
-
+        self._sut.set("irrelevent", "123", 5)
         fallback_cache_mock.assert_called_once()
 
     @patch("cache_fallback.cache.logger")
     @patch.object(FallbackCache, "_call_main_cache")
     def test_get_fallbackcache_logger(self, maincache_mock, logger_mock):
-        client = get_client()
         maincache_mock.side_effect = Exception()
-        client.get("irrelevent")
-
+        self._sut.get("irrelevent")
         logger_mock.warning.assert_called_with("Switch to fallback cache")
         logger_mock.exception.assert_called_once()