fix version checking and module checking logic

Author: tylerhutcherson

tests/conftest.py

@@ -4,8 +4,9 @@
 import pytest
 from testcontainers.compose import DockerCompose
 
+from redisvl.exceptions import RedisModuleVersionError
 from redisvl.index.index import AsyncSearchIndex, SearchIndex
-from redisvl.redis.connection import RedisConnectionFactory
+from redisvl.redis.connection import RedisConnectionFactory, compare_versions
 from redisvl.redis.utils import array_to_buffer
 from redisvl.utils.vectorize import HFTextVectorizer
 
@@ -424,3 +425,77 @@ def hash_preprocess(item: dict) -> dict:
 
     # run the test
     yield index
+
+
+# Version checking utilities
+def get_redis_version(client):
+    """Get Redis version from client info."""
+    return client.info()["redis_version"]
+
+
+async def get_redis_version_async(client):
+    """Get Redis version from async client info."""
+    info = await client.info()
+    return info["redis_version"]
+
+
+def skip_if_redis_version_below(client, min_version: str, message: str = None):
+    """
+    Skip test if Redis version is below minimum required.
+
+    Args:
+        client: Redis client instance
+        min_version: Minimum required Redis version
+        message: Custom skip message
+    """
+    redis_version = get_redis_version(client)
+    if not compare_versions(redis_version, min_version):
+        skip_msg = message or f"Redis version {redis_version} < {min_version} required"
+        pytest.skip(skip_msg)
+
+
+async def skip_if_redis_version_below_async(
+    client, min_version: str, message: str = None
+):
+    """
+    Skip test if Redis version is below minimum required (async version).
+
+    Args:
+        client: Async Redis client instance
+        min_version: Minimum required Redis version
+        message: Custom skip message
+    """
+    redis_version = await get_redis_version_async(client)
+    if not compare_versions(redis_version, min_version):
+        skip_msg = message or f"Redis version {redis_version} < {min_version} required"
+        pytest.skip(skip_msg)
+
+
+def skip_if_module_version_error(func, *args, **kwargs):
+    """
+    Execute function and skip test if RedisModuleVersionError is raised.
+
+    Args:
+        func: Function to execute
+        *args: Arguments for the function
+        **kwargs: Keyword arguments for the function
+    """
+    try:
+        return func(*args, **kwargs)
+    except RedisModuleVersionError:
+        pytest.skip("Required Redis modules not available or version too low")
+
+
+async def skip_if_module_version_error_async(func, *args, **kwargs):
+    """
+    Execute async function and skip test if RedisModuleVersionError is raised.
+
+    Args:
+        func: Async function to execute
+        *args: Arguments for the function
+        **kwargs: Keyword arguments for the function
+    """
+    try:
+        return await func(*args, **kwargs)
+    except RedisModuleVersionError:
+        pytest.skip("Required Redis modules not available or version too low")

tests/integration/test_aggregation.py

@@ -5,8 +5,8 @@
 from redisvl.index import SearchIndex
 from redisvl.query import HybridQuery
 from redisvl.query.filter import FilterExpression, Geo, GeoRadius, Num, Tag, Text
-from redisvl.redis.connection import compare_versions
 from redisvl.redis.utils import array_to_buffer
+from tests.conftest import skip_if_redis_version_below
 
 
 @pytest.fixture
@@ -60,9 +60,7 @@ def hash_preprocess(item: dict) -> dict:
 
 
 def test_aggregation_query(index):
-    redis_version = index.client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    skip_if_redis_version_below(index.client, "7.2.0")
 
     text = "a medical professional with expertise in lung cancer"
     text_field = "description"
@@ -141,9 +139,7 @@ def test_empty_query_string():
 
 
 def test_aggregation_query_with_filter(index):
-    redis_version = index.client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    skip_if_redis_version_below(index.client, "7.2.0")
 
     text = "a medical professional with expertise in lung cancer"
     text_field = "description"
@@ -169,9 +165,7 @@ def test_aggregation_query_with_filter(index):
 
 
 def test_aggregation_query_with_geo_filter(index):
-    redis_version = index.client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    skip_if_redis_version_below(index.client, "7.2.0")
 
     text = "a medical professional with expertise in lung cancer"
     text_field = "description"
@@ -197,9 +191,7 @@ def test_aggregation_query_with_geo_filter(index):
 
 @pytest.mark.parametrize("alpha", [0.1, 0.5, 0.9])
 def test_aggregate_query_alpha(index, alpha):
-    redis_version = index.client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    skip_if_redis_version_below(index.client, "7.2.0")
 
     text = "a medical professional with expertise in lung cancer"
     text_field = "description"
@@ -226,9 +218,7 @@ def test_aggregate_query_alpha(index, alpha):
 
 
 def test_aggregate_query_stopwords(index):
-    redis_version = index.client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    skip_if_redis_version_below(index.client, "7.2.0")
 
     text = "a medical professional with expertise in lung cancer"
     text_field = "description"
@@ -262,9 +252,7 @@ def test_aggregate_query_stopwords(index):
 
 
 def test_aggregate_query_with_text_filter(index):
-    redis_version = index.client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    skip_if_redis_version_below(index.client, "7.2.0")
 
     text = "a medical professional with expertise in lung cancer"
     text_field = "description"

tests/integration/test_connection.py

@@ -15,6 +15,10 @@
 )
 from redisvl.schema import IndexSchema
 from redisvl.version import __version__
+from tests.conftest import (
+    skip_if_redis_version_below,
+    skip_if_redis_version_below_async,
+)
 
 EXPECTED_LIB_NAME = f"redis-py(redisvl_v{__version__})"
 
@@ -166,38 +170,30 @@ def test_unknown_redis(self):
 
 
 def test_validate_redis(client):
-    redis_version = client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    skip_if_redis_version_below(client, "7.2.0")
     RedisConnectionFactory.validate_sync_redis(client)
     lib_name = client.client_info()
     assert lib_name["lib-name"] == EXPECTED_LIB_NAME
 
 
 @pytest.mark.asyncio
 async def test_validate_async_redis(async_client):
-    redis_version = (await async_client.info())["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    await skip_if_redis_version_below_async(async_client, "7.2.0")
     await RedisConnectionFactory.validate_async_redis(async_client)
     lib_name = await async_client.client_info()
     assert lib_name["lib-name"] == EXPECTED_LIB_NAME
 
 
 def test_validate_redis_custom_lib_name(client):
-    redis_version = client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    skip_if_redis_version_below(client, "7.2.0")
     RedisConnectionFactory.validate_sync_redis(client, "langchain_v0.1.0")
     lib_name = client.client_info()
     assert lib_name["lib-name"] == f"redis-py(redisvl_v{__version__};langchain_v0.1.0)"
 
 
 @pytest.mark.asyncio
 async def test_validate_async_redis_custom_lib_name(async_client):
-    redis_version = (await async_client.info())["redis_version"]
-    if not compare_versions(redis_version, "7.2.0"):
-        pytest.skip("Not using a late enough version of Redis")
+    await skip_if_redis_version_below_async(async_client, "7.2.0")
     await RedisConnectionFactory.validate_async_redis(async_client, "langchain_v0.1.0")
     lib_name = await async_client.client_info()
     assert lib_name["lib-name"] == f"redis-py(redisvl_v{__version__};langchain_v0.1.0)"

tests/integration/test_llmcache.py

@@ -13,6 +13,7 @@
 from redisvl.index.index import AsyncSearchIndex, SearchIndex
 from redisvl.query.filter import Num, Tag, Text
 from redisvl.utils.vectorize import HFTextVectorizer
+from tests.conftest import skip_if_module_version_error
 
 
 @pytest.fixture
@@ -935,21 +936,24 @@ def test_create_cache_with_different_vector_types(worker_id):
         for cache in [bfloat_cache, float16_cache, float32_cache, float64_cache]:
             cache.set_threshold(0.6)
             assert len(cache.check("float prompt", num_results=5)) == 1
-    except:
-        pytest.skip("Not using a late enough version of Redis")
+    except RedisModuleVersionError:
+        pytest.skip("Required Redis modules not available or version too low")
 
 
 def test_bad_dtype_connecting_to_existing_cache(redis_url, worker_id):
-    try:
-        cache = SemanticCache(
+    def create_cache():
+        return SemanticCache(
             name=f"float64_cache_{worker_id}", dtype="float64", redis_url=redis_url
         )
-        same_type = SemanticCache(
+
+    def create_same_type():
+        return SemanticCache(
             name=f"float64_cache_{worker_id}", dtype="float64", redis_url=redis_url
         )
-        # under the hood uses from_existing
-    except RedisModuleVersionError:
-        pytest.skip("Not using a late enough version of Redis")
+
+    cache = skip_if_module_version_error(create_cache)
+    same_type = skip_if_module_version_error(create_same_type)
+    # under the hood uses from_existing
 
     with pytest.raises(ValueError):
         bad_type = SemanticCache(

tests/integration/test_message_history.py

@@ -6,7 +6,7 @@
 from redisvl.exceptions import RedisModuleVersionError
 from redisvl.extensions.constants import ID_FIELD_NAME
 from redisvl.extensions.message_history import MessageHistory, SemanticMessageHistory
-from redisvl.utils.vectorize.text.huggingface import HFTextVectorizer
+from tests.conftest import skip_if_module_version_error
 
 
 @pytest.fixture
@@ -569,21 +569,24 @@ def test_different_vector_dtypes():
         for sess in [bfloat_sess, float16_sess, float32_sess, float64_sess]:
             sess.set_distance_threshold(0.7)
             assert len(sess.get_relevant("float message")) == 1
-    except:
-        pytest.skip("Not using a late enough version of Redis")
+    except RedisModuleVersionError:
+        pytest.skip("Required Redis modules not available or version too low")
 
 
 def test_bad_dtype_connecting_to_exiting_history(redis_url):
-    try:
-        history = SemanticMessageHistory(
+    def create_history():
+        return SemanticMessageHistory(
             name="float64 history", dtype="float64", redis_url=redis_url
         )
-        same_type = SemanticMessageHistory(
+
+    def create_same_type():
+        return SemanticMessageHistory(
             name="float64 history", dtype="float64", redis_url=redis_url
         )
-        # under the hood uses from_existing
-    except RedisModuleVersionError:
-        pytest.skip("Not using a late enough version of Redis")
+
+    history = skip_if_module_version_error(create_history)
+    same_type = skip_if_module_version_error(create_same_type)
+    # under the hood uses from_existing
 
     with pytest.raises(ValueError):
         bad_type = SemanticMessageHistory(

tests/integration/test_query.py

@@ -24,6 +24,7 @@
 )
 from redisvl.redis.connection import compare_versions
 from redisvl.redis.utils import array_to_buffer
+from tests.conftest import skip_if_redis_version_below
 
 
 @pytest.fixture
@@ -962,12 +963,11 @@ def missing_fields_index(worker_id, redis_url):
     missing_index.create(overwrite=True)
 
     # Skip all missing field tests if Redis version doesn't support INDEXMISSING/INDEXEMPTY (requires Redis 7.4+)
-    redis_version = missing_index.client.info()["redis_version"]
-    if not compare_versions(redis_version, "7.4.0"):
-        missing_index.delete(drop=True)  # Clean up before skipping
-        pytest.skip(
-            "INDEXMISSING/INDEXEMPTY features require Redis 7.4+ (RediSearch 2.10+)"
-        )
+    skip_if_redis_version_below(
+        missing_index.client,
+        "7.4.0",
+        "INDEXMISSING/INDEXEMPTY features require Redis 7.4+ (RediSearch 2.10+)",
+    )
 
     # Load test data with different missing field scenarios
     test_data = [