The fastest, litest AI Gateway. Rust core with Python SDK. Call 100+ LLM APIs in OpenAI (or native) format with cost tracking, guardrails, load balancing, and logging [Bedrock, Azure, OpenAI, Anthropic, OpenAI, VertexAI, vLLM, Nvidia NIM]
Python ai-gatewayanthropicazure-openaibedrockgatewaylangchainlitellmllmllm-gatewayllmopsmcp-gatewayopenaiopenai-proxyrustrust-aivertex-ai
"""
Tests for Router interactions API endpoint initialization functions.
"""
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from litellm import Router
class TestInitializeInteractionsEndpoints:
"""Test cases for _initialize_interactions_endpoints method"""
def test_initialize_interactions_endpoints_creates_methods(self):
"""Test that _initialize_interactions_endpoints creates the expected interaction methods on the router."""
router = Router(
model_list=[
{
"model_name": "gpt-4",
"litellm_params": {"model": "gpt-4"},
}
]
)
# Verify the interaction methods are created
assert hasattr(router, "acreate_interaction")
assert hasattr(router, "create_interaction")
assert hasattr(router, "aget_interaction")
assert hasattr(router, "get_interaction")
assert hasattr(router, "adelete_interaction")
assert hasattr(router, "delete_interaction")
assert hasattr(router, "acancel_interaction")
assert hasattr(router, "cancel_interaction")
# Verify they are callable
assert callable(router.acreate_interaction)
assert callable(router.create_interaction)
assert callable(router.aget_interaction)
assert callable(router.get_interaction)
def test_initialize_interactions_endpoints_can_be_called_directly(self):
"""Test that _initialize_interactions_endpoints can be called directly to reinitialize endpoints."""
router = Router(
model_list=[
{
"model_name": "gpt-4",
"litellm_params": {"model": "gpt-4"},
}
]
)
# Call _initialize_interactions_endpoints directly
router._initialize_interactions_endpoints()
# Verify the interaction methods still exist after re-initialization
assert hasattr(router, "acreate_interaction")
assert hasattr(router, "create_interaction")
assert callable(router.acreate_interaction)
class TestInitInteractionsApiEndpoints:
"""Test cases for _init_interactions_api_endpoints method"""
@pytest.mark.asyncio
async def test_init_interactions_api_endpoints_passes_custom_llm_provider(self):
"""Test that _init_interactions_api_endpoints passes custom_llm_provider to the original function."""
router = Router(
model_list=[
{
"model_name": "gpt-4",
"litellm_params": {"model": "gpt-4"},
}
]
)
mock_function = AsyncMock(return_value={"result": "success"})
result = await router._init_interactions_api_endpoints(
original_function=mock_function,
custom_llm_provider="gemini",
interaction_id="test-id",
)
mock_function.assert_called_once_with(
custom_llm_provider="gemini",
interaction_id="test-id",
)
assert result == {"result": "success"}
@pytest.mark.asyncio
async def test_init_interactions_api_endpoints_defaults_to_gemini(self):
"""Test that _init_interactions_api_endpoints defaults to gemini when no custom_llm_provider is specified."""
router = Router(
model_list=[
{
"model_name": "gpt-4",
"litellm_params": {"model": "gpt-4"},
}
]
)
mock_function = AsyncMock(return_value={"result": "success"})
result = await router._init_interactions_api_endpoints(
original_function=mock_function,
interaction_id="test-id",
)
mock_function.assert_called_once_with(
custom_llm_provider="gemini",
interaction_id="test-id",
)
assert result == {"result": "success"}
@pytest.mark.asyncio
async def test_init_interactions_api_endpoints_does_not_override_existing_provider(
self,
):
"""Test that _init_interactions_api_endpoints does not override custom_llm_provider if already in kwargs."""
router = Router(
model_list=[
{
"model_name": "gpt-4",
"litellm_params": {"model": "gpt-4"},
}
]
)
mock_function = AsyncMock(return_value={"result": "success"})
# Pass custom_llm_provider in kwargs directly (not as separate param)
result = await router._init_interactions_api_endpoints(
original_function=mock_function,
custom_llm_provider="vertex_ai",
)
# Should use the provided custom_llm_provider
mock_function.assert_called_once_with(
custom_llm_provider="vertex_ai",
)
assert result == {"result": "success"}
@pytest.mark.asyncio
async def test_init_interactions_api_endpoints_clears_model_when_equals_agent(
self,
):
"""Managed agent interactions must not pass agent name as model to the SDK."""
router = Router(model_list=[])
mock_function = AsyncMock(return_value={"result": "success"})
await router._init_interactions_api_endpoints(
original_function=mock_function,
agent="mqy-custom-slides-agent",
model="mqy-custom-slides-agent",
input="hello",
)
mock_function.assert_called_once_with(
custom_llm_provider="gemini",
agent="mqy-custom-slides-agent",
model=None,
input="hello",
)
class TestRouterCreateInteractionRouting:
"""acreate_interaction routing: agent-only vs model + fallbacks."""
@pytest.mark.asyncio
async def test_acreate_interaction_agent_only_uses_init_interactions(self):
"""Agent-only create must not use model-group fallback lookup."""
router = Router(
model_list=[
{
"model_name": "openai/*",
"litellm_params": {"model": "gpt-4"},
}
]
)
with (
patch.object(
router,
"_init_interactions_api_endpoints",
new_callable=AsyncMock,
return_value={"id": "int-1"},
) as mock_init,
patch.object(
router,
"_ageneric_api_call_with_fallbacks",
new_callable=AsyncMock,
) as mock_generic,
):
result = await router.acreate_interaction(
agent="mqy-custom-slides-agent",
input="hello",
custom_llm_provider="gemini",
)
mock_init.assert_called_once()
mock_generic.assert_not_called()
assert result == {"id": "int-1"}
@pytest.mark.asyncio
async def test_init_interactions_model_uses_generic_fallbacks(self):
"""Model-based create uses _ageneric_api_call_with_fallbacks inside _init_interactions."""
router = Router(model_list=[])
with patch.object(
router,
"_ageneric_api_call_with_fallbacks",
new_callable=AsyncMock,
return_value={"id": "int-1"},
) as mock_generic:
result = await router._init_interactions_api_endpoints(
original_function=AsyncMock(),
model="gemini-2.5-flash",
input="hello",
custom_llm_provider="gemini",
)
mock_generic.assert_called_once()
assert result == {"id": "int-1"}
class TestInitializeManagedAgentsEndpoints:
"""Tests for _initialize_managed_agents_endpoints."""
def test_initialize_managed_agents_endpoints_creates_methods(self):
router = Router(
model_list=[
{
"model_name": "gpt-4",
"litellm_params": {"model": "gpt-4"},
}
]
)
for method_name in (
"acreate_agent",
"alist_agents",
"aget_agent",
"adelete_agent",
"alist_agent_versions",
):
assert hasattr(router, method_name), f"missing {method_name}"
assert callable(getattr(router, method_name)), f"{method_name} not callable"
def test_initialize_managed_agents_endpoints_can_be_called_directly(self):
router = Router(model_list=[])
router._initialize_managed_agents_endpoints()
assert callable(router.acreate_agent)
assert callable(router.alist_agents)
class TestInitManagedAgentsApiEndpoints:
"""Tests for _init_managed_agents_api_endpoints."""
@pytest.mark.asyncio
async def test_init_managed_agents_api_endpoints_defaults_to_gemini(self):
router = Router(model_list=[])
mock_fn = AsyncMock(return_value={"agents": []})
await router._init_managed_agents_api_endpoints(
original_function=mock_fn,
)
call_kwargs = mock_fn.call_args.kwargs
assert call_kwargs["custom_llm_provider"] == "gemini"
@pytest.mark.asyncio
async def test_init_managed_agents_api_endpoints_passes_custom_provider(self):
router = Router(model_list=[])
mock_fn = AsyncMock(return_value={"agents": []})
await router._init_managed_agents_api_endpoints(
original_function=mock_fn,
custom_llm_provider="vertex_ai",
)
call_kwargs = mock_fn.call_args.kwargs
assert call_kwargs["custom_llm_provider"] == "vertex_ai"
@pytest.mark.asyncio
async def test_init_managed_agents_api_endpoints_does_not_override_existing_provider(
self,
):
router = Router(model_list=[])
mock_fn = AsyncMock(return_value={"agents": []})
await router._init_managed_agents_api_endpoints(
original_function=mock_fn,
custom_llm_provider="vertex_ai",
)
mock_fn.assert_called_once_with(custom_llm_provider="vertex_ai")