Merge pull request #9 from ting-ff/bugfix/conditional-test-fixtures

Bugfix/conditional test fixtures

Author: zoltan-fedor

Pipfile

@@ -18,7 +18,7 @@ pytest-cov = "*"
 pytest-pep8 = "*"
 pytest-rerunfailures = "*"
 pytest-xdist = "*"
-pytest-xprocess = "*"
+pytest-xprocess = ">=1.0"
 redis = "*"
 sphinx = "*"
 tox = "*"

README.md

@@ -143,6 +143,29 @@ https://github.com/python/typed_ast/issues/97). Also with Pipenv you can't
 have a second Pipfile. This is why for now we don't have `mypy` listed as a dev package
 in the Pipfile.
 
+### Testing
+
+The test suite uses pytest and includes fixtures for testing different cache backends. The `caches` fixture in `tests/conftest.py` is parametrized to test various cache types (e.g., 'simple', 'filesystem', 'redis', 'memcached') and eviction strategies (e.g., 'time-based', 'rest-based', 'rest-and-time-based').
+
+The fixture conditionally depends on server fixtures (e.g., `redis_server`, `memcache_server`) based on the cache type being tested. This ensures that pytest only starts the servers that are actually needed for the test, reducing unnecessary overhead and preventing tests from failing due to missing servers if they don't need them.
+
+For example, if you are testing the 'simple' or 'filesystem' cache types, pytest will not attempt to start Redis or Memcached servers, as they are not required for these cache types.
+
+To run the tests, you can use the following commands:
+
+```
+# Run all tests
+$ pytest
+
+# Run tests for a specific cache type
+$ pytest -k "simple"
+
+# Run tests for a specific eviction strategy
+$ pytest -k "time-based"
+```
+
+For more information on the test fixtures and how they are used, see the `tests/conftest.py` file.
+
 ## Credits
 
 As this is a port of the popular [Flask-Caching](https://github.com/sh4nks/flask-caching) library

tests/async_tests/test_app.py

@@ -256,17 +256,27 @@ async def on_get(self, req, resp):
 @pytest.mark.parametrize("eviction_strategy", [
     *EVICTION_STRATEGIES
 ])
-def test_caching_content_type_json_only(tmp_path, redis_server, redis_sentinel_server,
-                                              memcache_server, async_cache_type, eviction_strategy):
+def test_caching_content_type_json_only(tmp_path, async_cache_type, eviction_strategy, request):
     """ Testing that the Content-Type header does NOT get cached
     when the CACHE_CONTENT_TYPE_JSON_ONLY = True is set, which means
     that no msgpack serialization is used in this case, which should mean this
     gives a nice performance bump when the Content-Type header caching is
     not required because the application/json Content-Type (which is the default
     in Falcon) is sufficient for the app.
     """
-    if async_cache_type == 'redissentinel' and os.getenv('TRAVIS', 'no') == 'yes':
-        pytest.skip("Unfortunately on Travis Redis Sentinel currently can't be installed")
+    # Handle cache types that require Redis
+    if async_cache_type == "redis":
+        request.getfixturevalue("redis_server")
+
+    elif async_cache_type == 'redissentinel':
+        if os.getenv('TRAVIS', 'no') == 'yes':
+            pytest.skip("Unfortunately on Travis Redis Sentinel currently can't be installed")
+
+        request.getfixturevalue("redis_sentinel_server")
+
+    # Handle cache types that require Memcached
+    elif async_cache_type in ("memcached", "gaememcached"):
+        request.getfixturevalue("memcache_server")
 
     if True:
         cache = AsyncCache(

tests/conftest.py

@@ -11,7 +11,6 @@
 from falcon_caching.cache import SUPPORTED_HASH_FUNCTIONS
 
 try:
-    __import__("pytest_xprocess")
     from xprocess import ProcessStarter
 except ImportError:
 
@@ -95,15 +94,26 @@ def pytest_sessionfinish(session, exitstatus):
 
 # parametrized fixture to create caches with different types (eg backends)
 @pytest.fixture(params=CACHE_TYPES)
-def caches(request, tmp_path, redis_server, redis_sentinel_server, memcache_server):
+def caches(request, tmp_path):
     """ Time-based cache parametrized to generate a cache
     for each cache_type (eg backend)
     """
-    if request.param == 'redissentinel' and os.getenv('TRAVIS', 'no') == 'yes':
-        pytest.skip("Unfortunately on Travis Redis Sentinel currently can't be installed")
+    # Handle cache types that require Redis
+    if request.param == "redis":
+        request.getfixturevalue("redis_server")
+    elif request.param == "redissentinel":
+        # check if we are on travis, if so skip this test
+        if os.getenv("TRAVIS", "no") == "yes":
+            pytest.skip("Unfortunately on Travis Redis Sentinel currently can't be installed")
+
+        request.getfixturevalue("redis_sentinel_server")
+
+    # Handle cache types that require Memcached
+    elif request.param in ("memcached", "gaememcached", "saslmemcached", "spreadsaslmemcached"):
+        request.getfixturevalue("memcache_server")
 
     # uwsgi tests should only run if running under uwsgi
-    if request.param == 'uwsgi':
+    elif request.param == "uwsgi":
         try:
             import uwsgi
         except ImportError:
@@ -129,12 +139,22 @@ def caches(request, tmp_path, redis_server, redis_sentinel_server, memcache_serv
 
 # parametrized fixture to create caches with different types (eg backends)
 @pytest.fixture(params=ASYNC_CACHE_TYPES)
-def async_caches(request, tmp_path, redis_server, redis_sentinel_server, memcache_server):
-    """ Time-based cache parametrized to generate a cache
+def async_caches(request, tmp_path):
+    """Time-based cache parametrized to generate a cache
     for each cache_type (eg backend)
     """
-    if request.param == 'redissentinel' and os.getenv('TRAVIS', 'no') == 'yes':
-        pytest.skip("Unfortunately on Travis Redis Sentinel currently can't be installed")
+    # Handle cache types that require Redis
+    if request.param == "redis":
+        request.getfixturevalue("redis_server")
+    elif request.param == "redissentinel":
+        if os.getenv("TRAVIS", "no") == "yes":
+            pytest.skip("Unfortunately on Travis Redis Sentinel currently can't be installed")
+
+        request.getfixturevalue("redis_sentinel_server")
+
+    # Handle cache types that require Memcached
+    elif request.param in ("memcached", "gaememcached"):
+        request.getfixturevalue("memcache_server")
 
     # build a dict of caches for each eviction strategy
     caches = {

tests/test_app.py

@@ -231,20 +231,30 @@ def on_get(self, req, resp):
 @pytest.mark.parametrize("eviction_strategy", [
     *EVICTION_STRATEGIES
 ])
-def test_caching_content_type_json_only(tmp_path, redis_server, redis_sentinel_server,
-                                        memcache_server, cache_type, eviction_strategy):
+def test_caching_content_type_json_only(tmp_path, cache_type, eviction_strategy, request):
     """ Testing that the Content-Type header does NOT get cached
     when the CACHE_CONTENT_TYPE_JSON_ONLY = True is set, which means
     that no msgpack serialization is used in this case, which should mean this
     gives a nice performance bump when the Content-Type header caching is
     not required because the application/json Content-Type (which is the default
     in Falcon) is sufficient for the app.
     """
-    if cache_type == 'redissentinel' and os.getenv('TRAVIS', 'no') == 'yes':
-        pytest.skip("Unfortunately on Travis Redis Sentinel currently can't be installed")
+    # Handle cache types that require Redis
+    if cache_type == "redis":
+        request.getfixturevalue("redis_server")
+
+    elif cache_type == 'redissentinel':
+        if os.getenv('TRAVIS', 'no') == 'yes':
+            pytest.skip("Unfortunately on Travis Redis Sentinel currently can't be installed")
+
+        request.getfixturevalue("redis_sentinel_server")
+
+    # Handle cache types that require Memcached
+    elif cache_type in ("memcached", "gaememcached", "saslmemcached", "spreadsaslmemcached"):
+        request.getfixturevalue("memcache_server")
 
     # uwsgi tests should only run if running under uwsgi
-    if cache_type == 'uwsgi':
+    elif cache_type == 'uwsgi':
         try:
             import uwsgi
         except ImportError: