mirror of
https://github.com/BerriAI/litellm.git
synced 2026-11-16 09:22:22 +00:00
test: keep test_redis_cache.py formatting untouched, add only the contract test
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_014ZDULyJPp17ZFiJenRxs2T
This commit is contained in:
parent
6636f1f562
commit
50e55f25a2
1 changed files with 90 additions and 33 deletions
|
|
@ -55,7 +55,9 @@ def test_check_and_fix_namespace_prefixes_keys_sharing_the_namespace_prefix(
|
|||
|
||||
@pytest.mark.parametrize("namespace", [None, "litellm"])
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_delete_cache_applies_namespace(namespace, monkeypatch, redis_no_ping):
|
||||
async def test_async_delete_cache_applies_namespace(
|
||||
namespace, monkeypatch, redis_no_ping
|
||||
):
|
||||
"""async_delete_cache must prefix keys with the namespace, matching every
|
||||
other cache operation. Without this, Redis NOPERM errors occur when an
|
||||
ACL restricts DEL to the litellm:* pattern."""
|
||||
|
|
@ -63,7 +65,9 @@ async def test_async_delete_cache_applies_namespace(namespace, monkeypatch, redi
|
|||
redis_cache = RedisCache(namespace=namespace)
|
||||
mock_redis_instance = AsyncMock()
|
||||
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
await redis_cache.async_delete_cache(key="3997c4abcdef")
|
||||
|
||||
expected_key = "litellm:3997c4abcdef" if namespace else "3997c4abcdef"
|
||||
|
|
@ -126,7 +130,9 @@ async def test_handle_lpop_count_for_older_redis_versions(monkeypatch):
|
|||
]
|
||||
|
||||
# Test the helper method
|
||||
result = await redis_cache.handle_lpop_count_for_older_redis_versions(pipe=mock_pipeline, key="test_key", count=2)
|
||||
result = await redis_cache.handle_lpop_count_for_older_redis_versions(
|
||||
pipe=mock_pipeline, key="test_key", count=2
|
||||
)
|
||||
|
||||
# Verify results
|
||||
assert result == [b"value1", b"value2"]
|
||||
|
|
@ -135,14 +141,18 @@ async def test_handle_lpop_count_for_older_redis_versions(monkeypatch):
|
|||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_rpush_pipeline_empty_list_returns_empty(monkeypatch, redis_no_ping):
|
||||
async def test_async_rpush_pipeline_empty_list_returns_empty(
|
||||
monkeypatch, redis_no_ping
|
||||
):
|
||||
"""Empty rpush_list should return empty list without touching Redis"""
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
redis_cache = RedisCache()
|
||||
|
||||
mock_redis_instance = AsyncMock()
|
||||
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
result = await redis_cache.async_rpush_pipeline(rpush_list=[])
|
||||
|
||||
assert result == []
|
||||
|
|
@ -157,7 +167,9 @@ async def test_async_lpop_pipeline_empty_list(monkeypatch, redis_no_ping):
|
|||
|
||||
mock_redis_instance = AsyncMock()
|
||||
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
result = await redis_cache.async_lpop_pipeline(lpop_list=[])
|
||||
|
||||
assert result == []
|
||||
|
|
@ -182,7 +194,9 @@ async def test_async_lpop_pipeline_empty_list(monkeypatch, redis_no_ping):
|
|||
],
|
||||
)
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_register_script_namespaces_keys(namespace, raw_keys, expected_keys, monkeypatch, redis_no_ping):
|
||||
async def test_async_register_script_namespaces_keys(
|
||||
namespace, raw_keys, expected_keys, monkeypatch, redis_no_ping
|
||||
):
|
||||
"""The callable returned by async_register_script (used by the rate limiter
|
||||
Lua scripts, pod-lock release, and budget limiters) must namespace every key
|
||||
it is invoked with. The hash tag is preserved so cluster slotting is intact."""
|
||||
|
|
@ -193,12 +207,16 @@ async def test_async_register_script_namespaces_keys(namespace, raw_keys, expect
|
|||
mock_redis_instance = MagicMock()
|
||||
mock_redis_instance.register_script = MagicMock(return_value=registered_script)
|
||||
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
script = redis_cache.async_register_script("return 1")
|
||||
result = await script(keys=raw_keys, args=[60])
|
||||
|
||||
assert result == "ok"
|
||||
registered_script.assert_awaited_once_with(keys=tuple(expected_keys), args=[60], client=None)
|
||||
registered_script.assert_awaited_once_with(
|
||||
keys=tuple(expected_keys), args=[60], client=None
|
||||
)
|
||||
|
||||
|
||||
# LIT-3298: rate limits tripped at ~40M instead of 80M. async_register_script
|
||||
|
|
@ -236,8 +254,12 @@ def test_async_register_script_binds_per_event_loop(namespace, monkeypatch):
|
|||
loop_a = asyncio.new_event_loop()
|
||||
loop_b = asyncio.new_event_loop()
|
||||
try:
|
||||
result_a = loop_a.run_until_complete(script(keys=["{k:v}:tokens"], args=[60]))
|
||||
result_b = loop_b.run_until_complete(script(keys=["{k:v}:tokens"], args=[60]))
|
||||
result_a = loop_a.run_until_complete(
|
||||
script(keys=["{k:v}:tokens"], args=[60])
|
||||
)
|
||||
result_b = loop_b.run_until_complete(
|
||||
script(keys=["{k:v}:tokens"], args=[60])
|
||||
)
|
||||
finally:
|
||||
loop_a.close()
|
||||
loop_b.close()
|
||||
|
|
@ -250,7 +272,9 @@ def test_async_register_script_binds_per_event_loop(namespace, monkeypatch):
|
|||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_register_script_not_shared_across_namespaces(monkeypatch, redis_no_ping):
|
||||
async def test_async_register_script_not_shared_across_namespaces(
|
||||
monkeypatch, redis_no_ping
|
||||
):
|
||||
"""Two caches with different namespaces registering the SAME script must
|
||||
each run against their own client and key prefix. A content-only executor
|
||||
cache would let the second cache reuse the first's executor and namespace."""
|
||||
|
|
@ -266,10 +290,9 @@ async def test_async_register_script_not_shared_across_namespaces(monkeypatch, r
|
|||
client_b.register_script = MagicMock(return_value=reg_b)
|
||||
|
||||
same_script = "return redis.call('GET', KEYS[1])"
|
||||
with (
|
||||
patch.object(cache_a, "init_async_client", return_value=client_a),
|
||||
patch.object(cache_b, "init_async_client", return_value=client_b),
|
||||
):
|
||||
with patch.object(
|
||||
cache_a, "init_async_client", return_value=client_a
|
||||
), patch.object(cache_b, "init_async_client", return_value=client_b):
|
||||
script_a = cache_a.async_register_script(same_script)
|
||||
script_b = cache_b.async_register_script(same_script)
|
||||
result_a = await script_a(keys=["k"], args=[])
|
||||
|
|
@ -281,7 +304,9 @@ async def test_async_register_script_not_shared_across_namespaces(monkeypatch, r
|
|||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_register_script_cluster_path_uses_evalsha(monkeypatch, redis_no_ping):
|
||||
async def test_async_register_script_cluster_path_uses_evalsha(
|
||||
monkeypatch, redis_no_ping
|
||||
):
|
||||
"""Redis Cluster exposes script_load/evalsha rather than register_script.
|
||||
The script is loaded once and invoked via evalsha with namespaced keys."""
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
|
|
@ -291,17 +316,23 @@ async def test_async_register_script_cluster_path_uses_evalsha(monkeypatch, redi
|
|||
cluster_client.script_load = MagicMock(return_value="sha123")
|
||||
cluster_client.evalsha = AsyncMock(return_value="cluster-ok")
|
||||
|
||||
with patch.object(redis_cache, "init_async_client", return_value=cluster_client):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=cluster_client
|
||||
):
|
||||
script = redis_cache.async_register_script("return 'cluster'")
|
||||
result = await script(keys=["{k:v}:tokens"], args=[5, 60])
|
||||
|
||||
assert result == "cluster-ok"
|
||||
cluster_client.script_load.assert_called_once_with("return 'cluster'")
|
||||
cluster_client.evalsha.assert_awaited_once_with("sha123", 1, "ns:{k:v}:tokens", 5, 60)
|
||||
cluster_client.evalsha.assert_awaited_once_with(
|
||||
"sha123", 1, "ns:{k:v}:tokens", 5, 60
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_register_script_raises_for_unsupported_client(monkeypatch, redis_no_ping):
|
||||
async def test_async_register_script_raises_for_unsupported_client(
|
||||
monkeypatch, redis_no_ping
|
||||
):
|
||||
"""A client exposing neither register_script nor script_load fails loudly
|
||||
rather than silently returning a no-op callable."""
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
|
|
@ -316,34 +347,46 @@ async def test_async_register_script_raises_for_unsupported_client(monkeypatch,
|
|||
|
||||
@pytest.mark.parametrize("namespace, expected", [(None, "k"), ("ns", "ns:k")])
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_delete_cache_namespaces_key(namespace, expected, monkeypatch, redis_no_ping):
|
||||
async def test_async_delete_cache_namespaces_key(
|
||||
namespace, expected, monkeypatch, redis_no_ping
|
||||
):
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
redis_cache = RedisCache(namespace=namespace)
|
||||
mock_redis_instance = AsyncMock()
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
await redis_cache.async_delete_cache("k")
|
||||
mock_redis_instance.delete.assert_awaited_once_with(expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("namespace, expected", [(None, "k"), ("ns", "ns:k")])
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_cache_keys_namespaces_keys(namespace, expected, monkeypatch, redis_no_ping):
|
||||
async def test_delete_cache_keys_namespaces_keys(
|
||||
namespace, expected, monkeypatch, redis_no_ping
|
||||
):
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
redis_cache = RedisCache(namespace=namespace)
|
||||
mock_redis_instance = AsyncMock()
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
await redis_cache.delete_cache_keys(["k"])
|
||||
mock_redis_instance.delete.assert_awaited_once_with(expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("namespace, expected", [(None, "k"), ("ns", "ns:k")])
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_get_ttl_namespaces_key(namespace, expected, monkeypatch, redis_no_ping):
|
||||
async def test_async_get_ttl_namespaces_key(
|
||||
namespace, expected, monkeypatch, redis_no_ping
|
||||
):
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
redis_cache = RedisCache(namespace=namespace)
|
||||
mock_redis_instance = AsyncMock()
|
||||
mock_redis_instance.ttl = AsyncMock(return_value=42)
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
ttl = await redis_cache.async_get_ttl("k")
|
||||
assert ttl == 42
|
||||
mock_redis_instance.ttl.assert_awaited_once_with(expected)
|
||||
|
|
@ -351,31 +394,41 @@ async def test_async_get_ttl_namespaces_key(namespace, expected, monkeypatch, re
|
|||
|
||||
@pytest.mark.parametrize("namespace, expected", [(None, "k"), ("ns", "ns:k")])
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_lpop_namespaces_key(namespace, expected, monkeypatch, redis_no_ping):
|
||||
async def test_async_lpop_namespaces_key(
|
||||
namespace, expected, monkeypatch, redis_no_ping
|
||||
):
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
redis_cache = RedisCache(namespace=namespace)
|
||||
mock_redis_instance = AsyncMock()
|
||||
mock_redis_instance.lpop = AsyncMock(return_value=b"value")
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
await redis_cache.async_lpop(key="k")
|
||||
mock_redis_instance.lpop.assert_awaited_once_with(expected, None)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("namespace, expected", [(None, "k"), ("ns", "ns:k")])
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_rpush_namespaces_key(namespace, expected, monkeypatch, redis_no_ping):
|
||||
async def test_async_rpush_namespaces_key(
|
||||
namespace, expected, monkeypatch, redis_no_ping
|
||||
):
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
redis_cache = RedisCache(namespace=namespace)
|
||||
mock_redis_instance = AsyncMock()
|
||||
mock_redis_instance.rpush = AsyncMock(return_value=1)
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
await redis_cache.async_rpush("k", ["v"])
|
||||
mock_redis_instance.rpush.assert_awaited_once_with(expected, "v")
|
||||
|
||||
|
||||
@pytest.mark.parametrize("namespace, expected_match", [(None, "k*"), ("ns", "ns:k*")])
|
||||
@pytest.mark.asyncio
|
||||
async def test_async_scan_iter_namespaces_pattern(namespace, expected_match, monkeypatch, redis_no_ping):
|
||||
async def test_async_scan_iter_namespaces_pattern(
|
||||
namespace, expected_match, monkeypatch, redis_no_ping
|
||||
):
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
redis_cache = RedisCache(namespace=namespace)
|
||||
|
||||
|
|
@ -392,13 +445,17 @@ async def test_async_scan_iter_namespaces_pattern(namespace, expected_match, mon
|
|||
|
||||
mock_redis_instance = MagicMock()
|
||||
mock_redis_instance.scan_iter = scan_iter
|
||||
with patch.object(redis_cache, "init_async_client", return_value=mock_redis_instance):
|
||||
with patch.object(
|
||||
redis_cache, "init_async_client", return_value=mock_redis_instance
|
||||
):
|
||||
await redis_cache.async_scan_iter(pattern="k")
|
||||
assert captured["match"] == expected_match
|
||||
|
||||
|
||||
@pytest.mark.parametrize("namespace, expected", [(None, "k"), ("ns", "ns:k")])
|
||||
def test_increment_cache_namespaces_key(namespace, expected, monkeypatch, redis_no_ping):
|
||||
def test_increment_cache_namespaces_key(
|
||||
namespace, expected, monkeypatch, redis_no_ping
|
||||
):
|
||||
monkeypatch.setenv("REDIS_HOST", "https://my-test-host")
|
||||
redis_cache = RedisCache(namespace=namespace)
|
||||
mock_client = MagicMock()
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue