fix: use async_client fixture for async Redis connections in tests

- Replace manual AsyncRedis.from_url() with async_client fixture
- Remove unnecessary AsyncRedis import
- Remove manual client cleanup (handled by fixture)
- Follows the pattern used by all other async tests in the codebase

This properly uses the conftest async_client fixture which handles
the Redis connection with proper context manager cleanup.

Author: bsbodden

tests/integration/test_embedcache_warnings.py

@@ -5,47 +5,39 @@
 
 import pytest
 from redis import Redis
-from redis.asyncio import Redis as AsyncRedis
 
 from redisvl.extensions.cache.embeddings import EmbeddingsCache
 
 
 @pytest.mark.asyncio
-async def test_sync_methods_warn_with_async_only_client(redis_url, caplog):
+async def test_sync_methods_warn_with_async_only_client(async_client, caplog):
     """Test that sync methods warn when only async client is provided."""
     # Reset the warning flag for testing
     EmbeddingsCache._warning_shown = False
 
-    # Create async redis client from the redis_url
-    async_client = await AsyncRedis.from_url(redis_url)
+    # Initialize EmbeddingsCache with only async_redis_client
+    cache = EmbeddingsCache(name="test_cache", async_redis_client=async_client)
 
-    try:
-        # Initialize EmbeddingsCache with only async_redis_client
-        cache = EmbeddingsCache(name="test_cache", async_redis_client=async_client)
-
-        # Capture log warnings
-        with caplog.at_level(logging.WARNING):
-            # First sync method call should warn
-            _ = cache.get_by_key("test_key")
+    # Capture log warnings
+    with caplog.at_level(logging.WARNING):
+        # First sync method call should warn
+        _ = cache.get_by_key("test_key")
 
-            # Check warning was logged
-            assert len(caplog.records) == 1
-            assert (
-                "initialized with async_redis_client only" in caplog.records[0].message
-            )
-            assert "Use async methods" in caplog.records[0].message
+        # Check warning was logged
+        assert len(caplog.records) == 1
+        assert (
+            "initialized with async_redis_client only" in caplog.records[0].message
+        )
+        assert "Use async methods" in caplog.records[0].message
 
-            # Clear captured logs
-            caplog.clear()
+        # Clear captured logs
+        caplog.clear()
 
-            # Second sync method call should NOT warn (flag prevents spam)
-            _ = cache.set(text="test", model_name="model", embedding=[0.1, 0.2])
+        # Second sync method call should NOT warn (flag prevents spam)
+        _ = cache.set(text="test", model_name="model", embedding=[0.1, 0.2])
 
-            # Should not have logged another warning
-            assert len(caplog.records) == 0
-    finally:
-        # Properly close the async client
-        await async_client.aclose()
+        # Should not have logged another warning
+        assert len(caplog.records) == 0
 
 
 def test_no_warning_with_sync_client(redis_url):
@@ -72,25 +64,18 @@ def test_no_warning_with_sync_client(redis_url):
 
 
 @pytest.mark.asyncio
-async def test_async_methods_no_warning(redis_url):
+async def test_async_methods_no_warning(async_client):
     """Test that async methods don't trigger warnings."""
     # Reset the warning flag for testing
     EmbeddingsCache._warning_shown = False
 
-    # Create async redis client from redis_url
-    async_client = await AsyncRedis.from_url(redis_url)
+    # Initialize EmbeddingsCache with only async_redis_client
+    cache = EmbeddingsCache(name="test_cache", async_redis_client=async_client)
 
-    try:
-        # Initialize EmbeddingsCache with only async_redis_client
-        cache = EmbeddingsCache(name="test_cache", async_redis_client=async_client)
+    with patch("redisvl.utils.log.get_logger") as mock_logger:
+        # Async methods should not warn
+        _ = await cache.aget_by_key("test_key")
+        _ = await cache.aset(text="test", model_name="model", embedding=[0.1, 0.2])
 
-        with patch("redisvl.utils.log.get_logger") as mock_logger:
-            # Async methods should not warn
-            _ = await cache.aget_by_key("test_key")
-            _ = await cache.aset(text="test", model_name="model", embedding=[0.1, 0.2])
-
-            # No warnings should have been logged
-            mock_logger.return_value.warning.assert_not_called()
-    finally:
-        # Properly close the async client
-        await async_client.aclose()
+        # No warnings should have been logged
+        mock_logger.return_value.warning.assert_not_called()