fix(tests): implement proper cleanup for async Redis clients

- Add global async_redis_client variable for reuse
- Implement close_async_redis_client function for proper cleanup
- Update test cases to include asyncTearDown method for cleanup
- Remove python3.8 from test environment due to end of support

Author: tanbro

tests/_catches.py

@@ -1,5 +1,5 @@
 from os import getenv
-from typing import Callable, Dict, List
+from typing import Callable, Dict, List, Optional
 from warnings import warn
 
 from redis import Redis
@@ -35,56 +35,76 @@
     load_dotenv()
 
 
+redis_client: Optional[Redis] = None
+async_redis_client: Optional[AsyncRedis] = None
+
+
 def redis_factory(**kwargs):
-    return Redis.from_url(REDIS_URL)
+    global redis_client
+    if redis_client is None:
+        redis_client = Redis.from_url(REDIS_URL)
+    return redis_client
 
 
 def async_redis_factory(**kwargs):
-    return AsyncRedis.from_url(REDIS_URL)
+    global async_redis_client
+    if async_redis_client is None:
+        async_redis_client = AsyncRedis.from_url(REDIS_URL)
+    return async_redis_client
+
+
+async def close_async_redis_client():
+    """关闭全局异步Redis客户端连接"""
+    global async_redis_client
+    if async_redis_client is not None:
+        await async_redis_client.close()
+        async_redis_client = None
 
 
 MAXSIZE = 8
 
 REDIS_URL = getenv("REDIS_URL", "redis://")
+REDIS_FACTORY = lambda: Redis.from_url(REDIS_URL)  # noqa: E731
+ASYNC_REDIS_FACTORY = lambda: AsyncRedis.from_url(REDIS_URL)  # noqa: E731
 REDIS_CLUSTER_NODES = getenv("REDIS_CLUSTER_NODES")
 
 
 CACHES = {
-    "tlru": RedisFuncCache(__name__, LruTPolicy, client=redis_factory, maxsize=MAXSIZE),
-    "lru": RedisFuncCache(__name__, LruPolicy, client=redis_factory, maxsize=MAXSIZE),
-    "mru": RedisFuncCache(__name__, MruPolicy, client=redis_factory, maxsize=MAXSIZE),
-    "rr": RedisFuncCache(__name__, RrPolicy, client=redis_factory, maxsize=MAXSIZE),
-    "fifo": RedisFuncCache(__name__, FifoPolicy, client=redis_factory, maxsize=MAXSIZE),
-    "lfu": RedisFuncCache(__name__, LfuPolicy, client=redis_factory, maxsize=MAXSIZE),
+    "tlru": RedisFuncCache(__name__, LruTPolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "lru": RedisFuncCache(__name__, LruPolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "mru": RedisFuncCache(__name__, MruPolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "rr": RedisFuncCache(__name__, RrPolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "fifo": RedisFuncCache(__name__, FifoPolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "lfu": RedisFuncCache(__name__, LfuPolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
 }
 
 MULTI_CACHES = {
-    "tlru": RedisFuncCache(__name__, LruTMultiplePolicy, client=redis_factory, maxsize=MAXSIZE),
-    "lru": RedisFuncCache(__name__, LruMultiplePolicy, client=redis_factory, maxsize=MAXSIZE),
-    "mru": RedisFuncCache(__name__, MruMultiplePolicy, client=redis_factory, maxsize=MAXSIZE),
-    "rr": RedisFuncCache(__name__, RrMultiplePolicy, client=redis_factory, maxsize=MAXSIZE),
-    "fifo": RedisFuncCache(__name__, FifoMultiplePolicy, client=redis_factory, maxsize=MAXSIZE),
-    "lfu": RedisFuncCache(__name__, LfuMultiplePolicy, client=redis_factory, maxsize=MAXSIZE),
+    "tlru": RedisFuncCache(__name__, LruTMultiplePolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "lru": RedisFuncCache(__name__, LruMultiplePolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "mru": RedisFuncCache(__name__, MruMultiplePolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "rr": RedisFuncCache(__name__, RrMultiplePolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "fifo": RedisFuncCache(__name__, FifoMultiplePolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
+    "lfu": RedisFuncCache(__name__, LfuMultiplePolicy, client=REDIS_FACTORY, maxsize=MAXSIZE),
 }
 
 
 ASYNC_CACHES = {
-    "tlru": RedisFuncCache(__name__, LruTPolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "lru": RedisFuncCache(__name__, LruPolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "mru": RedisFuncCache(__name__, MruPolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "rr": RedisFuncCache(__name__, RrPolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "fifo": RedisFuncCache(__name__, FifoPolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "lfu": RedisFuncCache(__name__, LfuPolicy, client=async_redis_factory, maxsize=MAXSIZE),
+    "tlru": RedisFuncCache(__name__, LruTPolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "lru": RedisFuncCache(__name__, LruPolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "mru": RedisFuncCache(__name__, MruPolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "rr": RedisFuncCache(__name__, RrPolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "fifo": RedisFuncCache(__name__, FifoPolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "lfu": RedisFuncCache(__name__, LfuPolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
 }
 
 
 ASYNC_MULTI_CACHES = {
-    "tlru": RedisFuncCache(__name__, LruTMultiplePolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "lru": RedisFuncCache(__name__, LruMultiplePolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "mru": RedisFuncCache(__name__, MruMultiplePolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "rr": RedisFuncCache(__name__, RrMultiplePolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "fifo": RedisFuncCache(__name__, FifoMultiplePolicy, client=async_redis_factory, maxsize=MAXSIZE),
-    "lfu": RedisFuncCache(__name__, LfuMultiplePolicy, client=async_redis_factory, maxsize=MAXSIZE),
+    "tlru": RedisFuncCache(__name__, LruTMultiplePolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "lru": RedisFuncCache(__name__, LruMultiplePolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "mru": RedisFuncCache(__name__, MruMultiplePolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "rr": RedisFuncCache(__name__, RrMultiplePolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "fifo": RedisFuncCache(__name__, FifoMultiplePolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
+    "lfu": RedisFuncCache(__name__, LfuMultiplePolicy, client=ASYNC_REDIS_FACTORY, maxsize=MAXSIZE),
 }
 
 CLUSTER_NODES: List[ClusterNode] = []

tests/run.sh

@@ -6,7 +6,7 @@ export PIP_ROOT_USER_ACTION=ignore
 export PIP_NO_WARN_SCRIPT_LOCATION=1
 
 
-PYTHON_LIST=(python3.8 python3.9 python3.10 python3.11 python3.12 python3.13)
+PYTHON_LIST=(python3.9 python3.10 python3.11 python3.12 python3.13)
 for PYTHON in ${PYTHON_LIST[@]}
 do
     echo

tests/test_async.py

@@ -3,7 +3,7 @@
 from unittest import IsolatedAsyncioTestCase
 from unittest.mock import AsyncMock, patch
 
-from ._catches import ASYNC_CACHES, ASYNC_MULTI_CACHES, CACHES
+from ._catches import ASYNC_CACHES, ASYNC_MULTI_CACHES, CACHES, close_async_redis_client
 
 
 def _echo(x):
@@ -15,6 +15,10 @@ async def asyncSetUp(self):
         coros = (cache.policy.apurge() for cache in ASYNC_CACHES.values())
         await asyncio.gather(*coros)
 
+    async def asyncTearDown(self):
+        # 清理异步Redis客户端连接
+        await close_async_redis_client()
+
     async def test_simple(self):
         for cache in ASYNC_CACHES.values():
 
@@ -36,6 +40,10 @@ async def asyncSetUp(self):
         coros = (cache.policy.apurge() for cache in ASYNC_MULTI_CACHES.values())
         await asyncio.gather(*coros)
 
+    async def asyncTearDown(self):
+        # 清理异步Redis客户端连接
+        await close_async_redis_client()
+
     async def test_simple(self):
         for cache in ASYNC_MULTI_CACHES.values():
 

tests/test_async_context.py

@@ -11,6 +11,10 @@ async def asyncSetUp(self):
         coros = (cache.policy.apurge() for cache in ASYNC_CACHES.values())
         await asyncio.gather(*coros)
 
+    async def asyncTearDown(self):
+        # 正确关闭所有异步Redis客户端连接，防止"Event loop is closed"错误
+        await asyncio.gather(*(cache.client.close() for cache in ASYNC_CACHES.values()))
+
     async def test_async_ttl_contextual(self):
         for cache in ASYNC_CACHES.values():