Updates: svs-vamana version capability validation tests

Author: Nitin Kanukolanu

tests/unit/test_fields.py

@@ -1,10 +1,15 @@
+from unittest.mock import AsyncMock, Mock, patch
+
 import pytest
 from redis.commands.search.field import GeoField as RedisGeoField
 from redis.commands.search.field import NumericField as RedisNumericField
 from redis.commands.search.field import TagField as RedisTagField
 from redis.commands.search.field import TextField as RedisTextField
 from redis.commands.search.field import VectorField as RedisVectorField
 
+from redisvl.exceptions import RedisModuleVersionError
+from redisvl.index import AsyncSearchIndex, SearchIndex
+from redisvl.schema import IndexSchema
 from redisvl.schema.fields import (
     FieldFactory,
     FlatVectorField,
@@ -636,3 +641,188 @@ def test_svs_vector_field_leanvec8x8_with_reduce():
     assert redis_field.args[redis_field.args.index("COMPRESSION") + 1] == "LeanVec8x8"
     assert "REDUCE" in redis_field.args
     assert redis_field.args[redis_field.args.index("REDUCE") + 1] == 512
+
+
+# ==================== SVS-VAMANA INDEX VALIDATION TESTS ====================
+
+
+def test_uses_svs_vamana_true():
+    """Test _uses_svs_vamana returns True for SVS schema."""
+    schema_dict = {
+        "index": {"name": "test_index", "prefix": "doc"},
+        "fields": [
+            {"name": "id", "type": "tag"},
+            {
+                "name": "embedding",
+                "type": "vector",
+                "attrs": {
+                    "dims": 128,
+                    "algorithm": "svs-vamana",
+                    "datatype": "float32",
+                    "distance_metric": "cosine",
+                },
+            },
+        ],
+    }
+    schema = IndexSchema.from_dict(schema_dict)
+
+    mock_client = Mock()
+
+    with patch.object(SearchIndex, "_redis_client", mock_client):
+        index = SearchIndex(schema=schema)
+        assert index._uses_svs_vamana() is True
+
+
+def test_check_svs_support_raises_error():
+    """Test _check_svs_support raises error when not supported."""
+    schema_dict = {
+        "index": {"name": "test_index", "prefix": "doc"},
+        "fields": [
+            {
+                "name": "embedding",
+                "type": "vector",
+                "attrs": {
+                    "dims": 128,
+                    "algorithm": "svs-vamana",
+                    "datatype": "float32",
+                    "distance_metric": "cosine",
+                },
+            },
+        ],
+    }
+    schema = IndexSchema.from_dict(schema_dict)
+
+    mock_client = Mock()
+    mock_client.info.return_value = {"redis_version": "7.2.4"}
+
+    with patch(
+        "redisvl.redis.connection.RedisConnectionFactory.get_modules"
+    ) as mock_get_modules:
+        mock_get_modules.return_value = {"search": 20612, "searchlight": 20612}
+
+        index = SearchIndex(schema=schema)
+
+        # Mock the _redis_client property
+        with patch.object(
+            type(index),
+            "_redis_client",
+            new_callable=lambda: property(lambda self: mock_client),
+        ):
+            with pytest.raises(RedisModuleVersionError) as exc_info:
+                index._check_svs_support()
+
+            error_msg = str(exc_info.value)
+            assert "SVS-VAMANA requires Redis >= 8.2.0" in error_msg
+            assert "Redis 7.2.4" in error_msg
+
+
+def test_check_svs_support_passes():
+    """Test _check_svs_support passes when supported."""
+    schema_dict = {
+        "index": {"name": "test_index", "prefix": "doc"},
+        "fields": [
+            {
+                "name": "embedding",
+                "type": "vector",
+                "attrs": {
+                    "dims": 128,
+                    "algorithm": "svs-vamana",
+                    "datatype": "float32",
+                    "distance_metric": "cosine",
+                },
+            },
+        ],
+    }
+    schema = IndexSchema.from_dict(schema_dict)
+
+    mock_client = Mock()
+    mock_client.info.return_value = {"redis_version": "8.2.0"}
+
+    with patch(
+        "redisvl.redis.connection.RedisConnectionFactory.get_modules"
+    ) as mock_get_modules:
+        mock_get_modules.return_value = {"search": 20810, "searchlight": 20810}
+
+        index = SearchIndex(schema=schema)
+
+        # Mock the _redis_client property
+        with patch.object(
+            type(index),
+            "_redis_client",
+            new_callable=lambda: property(lambda self: mock_client),
+        ):
+            # Should not raise
+            index._check_svs_support()
+
+
+@pytest.mark.asyncio
+async def test_check_svs_support_async_raises_error():
+    """Test _check_svs_support_async raises error when not supported."""
+    schema_dict = {
+        "index": {"name": "test_index", "prefix": "doc"},
+        "fields": [
+            {
+                "name": "embedding",
+                "type": "vector",
+                "attrs": {
+                    "dims": 128,
+                    "algorithm": "svs-vamana",
+                    "datatype": "float32",
+                    "distance_metric": "cosine",
+                },
+            },
+        ],
+    }
+    schema = IndexSchema.from_dict(schema_dict)
+
+    mock_client = AsyncMock()
+    mock_client.info.return_value = {"redis_version": "7.2.4"}
+
+    with patch(
+        "redisvl.redis.connection.RedisConnectionFactory.get_modules_async"
+    ) as mock_get_modules:
+        mock_get_modules.return_value = {"search": 20612, "searchlight": 20612}
+
+        index = AsyncSearchIndex(schema=schema)
+
+        with patch.object(index, "_get_client", return_value=mock_client):
+            with pytest.raises(RedisModuleVersionError) as exc_info:
+                await index._check_svs_support_async()
+
+            error_msg = str(exc_info.value)
+            assert "SVS-VAMANA requires Redis >= 8.2.0" in error_msg
+
+
+@pytest.mark.asyncio
+async def test_check_svs_support_async_passes():
+    """Test _check_svs_support_async passes when supported."""
+    schema_dict = {
+        "index": {"name": "test_index", "prefix": "doc"},
+        "fields": [
+            {
+                "name": "embedding",
+                "type": "vector",
+                "attrs": {
+                    "dims": 128,
+                    "algorithm": "svs-vamana",
+                    "datatype": "float32",
+                    "distance_metric": "cosine",
+                },
+            },
+        ],
+    }
+    schema = IndexSchema.from_dict(schema_dict)
+
+    mock_client = AsyncMock()
+    mock_client.info.return_value = {"redis_version": "8.2.0"}
+
+    with patch(
+        "redisvl.redis.connection.RedisConnectionFactory.get_modules_async"
+    ) as mock_get_modules:
+        mock_get_modules.return_value = {"search": 20810, "searchlight": 20810}
+
+        index = AsyncSearchIndex(schema=schema)
+
+        with patch.object(index, "_get_client", return_value=mock_client):
+            # Should not raise
+            await index._check_svs_support_async()

tests/unit/test_svs_capability_detection.py

@@ -0,0 +1,178 @@
+"""
+Unit tests for SVS-VAMANA capability detection.
+
+Tests the core functionality that determines if SVS-VAMANA vector indexing
+is supported on the connected Redis instance.
+"""
+
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from redisvl.exceptions import RedisModuleVersionError
+from redisvl.redis.connection import (
+    VectorSupport,
+    async_supports_svs_vamana,
+    check_vector_capabilities,
+    check_vector_capabilities_async,
+    compare_versions,
+    format_module_version,
+    supports_svs_vamana,
+)
+
+# ============================================================================
+# Helper Function Tests
+# ============================================================================
+
+
+def test_format_version_20810():
+    """Test formatting version 20810 -> 2.8.10"""
+    assert format_module_version(20810) == "2.8.10"
+
+
+def test_compare_greater_version():
+    """Test version comparison: greater version returns True."""
+    assert compare_versions("8.2.0", "8.1.0") is True
+    assert compare_versions("8.2.1", "8.2.0") is True
+    assert compare_versions("9.0.0", "8.2.0") is True
+
+
+def test_compare_lesser_version():
+    """Test version comparison: lesser version returns False."""
+    assert compare_versions("7.2.4", "8.2.0") is False
+    assert compare_versions("8.1.9", "8.2.0") is False
+    assert compare_versions("8.2.0", "8.2.1") is False
+
+
+# ============================================================================
+# check_vector_capabilities Tests
+# ============================================================================
+
+
+def test_check_vector_capabilities_supported():
+    """Test check_vector_capabilities when SVS is supported."""
+    mock_client = Mock()
+    mock_client.info.return_value = {"redis_version": "8.2.0"}
+
+    with patch(
+        "redisvl.redis.connection.RedisConnectionFactory.get_modules"
+    ) as mock_get_modules:
+        mock_get_modules.return_value = {"search": 20810, "searchlight": 20810}
+
+        caps = check_vector_capabilities(mock_client)
+
+        assert caps.redis_version == "8.2.0"
+        assert caps.search_version == 20810
+        assert caps.searchlight_version == 20810
+        assert caps.svs_vamana_supported is True
+
+
+def test_check_vector_capabilities_old_redis():
+    """Test check_vector_capabilities with old Redis version."""
+    mock_client = Mock()
+    mock_client.info.return_value = {"redis_version": "7.2.4"}
+
+    with patch(
+        "redisvl.redis.connection.RedisConnectionFactory.get_modules"
+    ) as mock_get_modules:
+        mock_get_modules.return_value = {"search": 20810, "searchlight": 20810}
+
+        caps = check_vector_capabilities(mock_client)
+
+        assert caps.redis_version == "7.2.4"
+        assert caps.svs_vamana_supported is False
+
+
+def test_check_vector_capabilities_old_modules():
+    """Test check_vector_capabilities with old module versions."""
+    mock_client = Mock()
+    mock_client.info.return_value = {"redis_version": "8.2.0"}
+
+    with patch(
+        "redisvl.redis.connection.RedisConnectionFactory.get_modules"
+    ) as mock_get_modules:
+        mock_get_modules.return_value = {"search": 20612, "searchlight": 20612}
+
+        caps = check_vector_capabilities(mock_client)
+
+        assert caps.search_version == 20612
+        assert caps.searchlight_version == 20612
+        assert caps.svs_vamana_supported is False
+
+
+@pytest.mark.asyncio
+async def test_check_vector_capabilities_async_supported():
+    """Test check_vector_capabilities_async when SVS is supported."""
+    mock_client = AsyncMock()
+    mock_client.info.return_value = {"redis_version": "8.2.0"}
+
+    with patch(
+        "redisvl.redis.connection.RedisConnectionFactory.get_modules_async"
+    ) as mock_get_modules:
+        mock_get_modules.return_value = {"search": 20810, "searchlight": 20810}
+
+        caps = await check_vector_capabilities_async(mock_client)
+
+        assert caps.redis_version == "8.2.0"
+        assert caps.search_version == 20810
+        assert caps.svs_vamana_supported is True
+
+
+# ============================================================================
+# supports_svs_vamana Tests
+# ============================================================================
+
+
+def test_supports_svs_vamana_true():
+    """Test supports_svs_vamana returns True when supported."""
+    mock_client = Mock()
+    mock_client.info.return_value = {"redis_version": "8.2.0"}
+    mock_client.module_list.return_value = [
+        {"name": b"search", "ver": 20810},
+        {"name": b"searchlight", "ver": 20810},
+    ]
+
+    assert supports_svs_vamana(mock_client) is True
+
+
+def test_supports_svs_vamana_false_old_redis():
+    """Test supports_svs_vamana returns False with old Redis."""
+    mock_client = Mock()
+    mock_client.info.return_value = {"redis_version": "7.2.4"}
+    mock_client.module_list.return_value = [
+        {"name": b"search", "ver": 20810},
+    ]
+
+    assert supports_svs_vamana(mock_client) is False
+
+
+def test_supports_svs_vamana_exception_handling():
+    """Test supports_svs_vamana handles exceptions gracefully."""
+    mock_client = Mock()
+    mock_client.info.side_effect = Exception("Connection error")
+
+    assert supports_svs_vamana(mock_client) is False
+
+
+# ============================================================================
+# Exception Tests
+# ============================================================================
+
+
+def test_for_svs_vamana_error_message():
+    """Test RedisModuleVersionError.for_svs_vamana creates proper exception."""
+    caps = VectorSupport(
+        redis_version="7.2.4",
+        search_version=20612,
+        searchlight_version=20612,
+        svs_vamana_supported=False,
+    )
+
+    error = RedisModuleVersionError.for_svs_vamana(caps, "8.2.0")
+
+    error_msg = str(error)
+    assert "SVS-VAMANA requires Redis >= 8.2.0" in error_msg
+    assert "RediSearch >= 2.8.10" in error_msg
+    assert "Redis 7.2.4" in error_msg
+    assert "RediSearch 2.6.12" in error_msg
+    assert "SearchLight 2.6.12" in error_msg