remove RedisSessionManager tests, ruff

Author: rafaelpierre

tests/test_redis_session.py

@@ -7,7 +7,7 @@
 
 import pytest
 
-from agents.memory.providers.redis import RedisSession, RedisSessionManager
+from agents.memory.providers.redis import RedisSession
 
 
 class TestRedisSession:
@@ -336,214 +336,3 @@ def test_session_without_ttl(self):
         """Test session creation without TTL."""
         session = RedisSession("test_session", ttl=None)
         assert session.ttl is None
-
-
-class TestRedisSessionManager:
-    """Test cases for RedisSessionManager class."""
-
-    @pytest.fixture
-    def session_manager(self):
-        """Create a RedisSessionManager instance for testing."""
-        return RedisSessionManager(
-            redis_url="redis://localhost:6379",
-            db=1,
-            session_prefix="manager_session",
-            messages_prefix="manager_messages",
-            default_ttl=7200,
-            max_connections=5,
-        )
-
-    def test_init(self, session_manager):
-        """Test RedisSessionManager initialization."""
-        assert session_manager.redis_url == "redis://localhost:6379"
-        assert session_manager.db == 1
-        assert session_manager.session_prefix == "manager_session"
-        assert session_manager.messages_prefix == "manager_messages"
-        assert session_manager.default_ttl == 7200
-        # Note: We don't need to test the internal pool creation since it's an implementation detail
-
-    @patch('agents.memory.providers.redis.redis.Redis')
-    def test_get_session(self, mock_redis_class, session_manager):
-        """Test getting a session instance."""
-        mock_redis_instance = MagicMock()
-        mock_redis_class.return_value = mock_redis_instance
-
-        session = session_manager.get_session("test_session_456", ttl=1800)
-
-        assert isinstance(session, RedisSession)
-        assert session.session_id == "test_session_456"
-        assert session.redis_url == "redis://localhost:6379"
-        assert session.db == 1
-        assert session.session_prefix == "manager_session"
-        assert session.messages_prefix == "manager_messages"
-        assert session.ttl == 1800
-
-        # Verify Redis instance was created with connection pool
-        mock_redis_class.assert_called_once()
-        call_kwargs = mock_redis_class.call_args[1]
-        assert 'connection_pool' in call_kwargs
-        assert session._redis_client == mock_redis_instance
-
-    @patch('agents.memory.providers.redis.redis.ConnectionPool.from_url')
-    def test_get_session_default_ttl(self, mock_pool_from_url, session_manager):
-        """Test getting session with default TTL."""
-        session = session_manager.get_session("test_session_789")
-        assert session.ttl == 7200
-
-    @patch('agents.memory.providers.redis.redis.ConnectionPool.from_url')
-    @patch('agents.memory.providers.redis.redis.Redis')
-    async def test_list_sessions(self, mock_redis_class, mock_pool_from_url, session_manager):
-        """Test listing all sessions."""
-        mock_redis_instance = AsyncMock()
-        mock_redis_class.return_value = mock_redis_instance
-        mock_redis_instance.keys.return_value = [
-            "manager_session:session1",
-            "manager_session:session2",
-            "manager_session:session3"
-        ]
-
-        sessions = await session_manager.list_sessions()
-
-        mock_redis_instance.keys.assert_called_once_with("manager_session:*")
-        mock_redis_instance.aclose.assert_called_once()
-        assert sessions == ["session1", "session2", "session3"]
-
-    @patch('agents.memory.providers.redis.redis.ConnectionPool.from_url')
-    @patch('agents.memory.providers.redis.redis.Redis')
-    async def test_list_sessions_with_pattern(
-        self, mock_redis_class, mock_pool_from_url, session_manager
-    ):
-        """Test listing sessions with pattern filter."""
-        mock_redis_instance = AsyncMock()
-        mock_redis_class.return_value = mock_redis_instance
-        mock_redis_instance.keys.return_value = [
-            "manager_session:user_123_session1",
-            "manager_session:user_123_session2"
-        ]
-
-        sessions = await session_manager.list_sessions(pattern="user_123_*")
-
-        mock_redis_instance.keys.assert_called_once_with("manager_session:user_123_*")
-        assert sessions == ["user_123_session1", "user_123_session2"]
-
-    @patch('agents.memory.providers.redis.redis.ConnectionPool.from_url')
-    @patch('agents.memory.providers.redis.redis.Redis')
-    async def test_delete_session(self, mock_redis_class, mock_pool_from_url, session_manager):
-        """Test deleting a session."""
-        mock_redis_instance = AsyncMock()
-        mock_redis_class.return_value = mock_redis_instance
-        mock_redis_instance.delete.return_value = 2  # Both keys deleted
-
-        result = await session_manager.delete_session("test_session")
-
-        mock_redis_instance.delete.assert_called_once_with(
-            "manager_session:test_session",
-            "manager_messages:test_session"
-        )
-        mock_redis_instance.aclose.assert_called_once()
-        assert result is True
-
-    @patch('agents.memory.providers.redis.redis.ConnectionPool.from_url')
-    @patch('agents.memory.providers.redis.redis.Redis')
-    async def test_delete_session_not_exists(
-        self, mock_redis_class, mock_pool_from_url, session_manager
-    ):
-        """Test deleting non-existent session."""
-        mock_redis_instance = AsyncMock()
-        mock_redis_class.return_value = mock_redis_instance
-        mock_redis_instance.delete.return_value = 0  # No keys deleted
-
-        result = await session_manager.delete_session("nonexistent_session")
-
-        assert result is False
-
-    @patch('agents.memory.providers.redis.redis.ConnectionPool.from_url')
-    async def test_close(self, mock_pool_from_url, session_manager):
-        """Test closing connection pool."""
-        mock_pool = AsyncMock()
-        session_manager._redis_pool = mock_pool
-
-        await session_manager.close()
-
-        mock_pool.aclose.assert_called_once()
-
-    @patch('agents.memory.providers.redis.redis.ConnectionPool.from_url')
-    async def test_context_manager(self, mock_pool_from_url, session_manager):
-        """Test async context manager functionality."""
-        session_manager.close = AsyncMock()
-
-        async with session_manager as manager:
-            assert manager == session_manager
-
-        session_manager.close.assert_called_once()
-
-
-class TestRedisSessionIntegration:
-    """Integration tests for Redis session functionality."""
-
-    @pytest.fixture
-    def redis_session_no_ttl(self):
-        """Create a RedisSession without TTL for testing."""
-        return RedisSession("integration_test_session", ttl=None)
-
-    @patch('agents.memory.providers.redis.redis.from_url')
-    async def test_session_lifecycle(self, mock_from_url, redis_session_no_ttl, sample_items):
-        """Test complete session lifecycle operations."""
-        mock_redis = AsyncMock()
-        mock_from_url.return_value = mock_redis
-
-        # Create a proper async context manager mock
-        mock_pipeline = AsyncMock()
-        mock_context_manager = AsyncMock()
-        mock_context_manager.__aenter__.return_value = mock_pipeline
-        mock_context_manager.__aexit__.return_value = None
-
-        # Make pipeline() return the context manager directly (not a coroutine)
-        mock_redis.pipeline = MagicMock(return_value=mock_context_manager)
-
-        # Mock responses for different operations
-        mock_redis.exists.return_value = False
-        mock_redis.lrange.return_value = [json.dumps(item) for item in sample_items]
-        mock_redis.llen.return_value = len(sample_items)
-        mock_redis.rpop.return_value = json.dumps(sample_items[-1])
-        mock_redis.hgetall.return_value = {
-            "session_id": "integration_test_session",
-            "created_at": "1234567890.0",
-            "updated_at": "1234567890.0"
-        }
-
-        session = redis_session_no_ttl
-
-        # Add items
-        await session.add_items(sample_items)
-
-        # Get all items
-        items = await session.get_items()
-        assert len(items) == len(sample_items)
-
-        # Get session size
-        size = await session.get_session_size()
-        assert size == len(sample_items)
-
-        # Get session info
-        info = await session.get_session_info()
-        assert info["session_id"] == "integration_test_session"
-
-        # Pop last item
-        popped_item = await session.pop_item()
-        assert popped_item == sample_items[-1]
-
-        # Clear session
-        await session.clear_session()
-
-        # Close session
-        await session.close()
-
-    @pytest.fixture
-    def sample_items(self):
-        """Create sample items for integration testing."""
-        return [
-            {"role": "user", "content": [{"type": "text", "text": "Hello"}]},
-            {"role": "assistant", "content": [{"type": "text", "text": "Hi there!"}]},
-            {"role": "user", "content": [{"type": "text", "text": "How are you?"}]},
-        ]