Add unit tests for the backoff module

Signed-off-by: camille-bouvy-frequenz <[email protected]>

Author: camille-bouvy-frequenz

tests/test_backoff.py

@@ -0,0 +1,218 @@
+# License: MIT
+# Copyright © 2024 Frequenz Energy-as-a-Service GmbH
+
+"""Tests for the backoff strategy to handle non-successful gRPC connection attempts."""
+
+import asyncio
+from unittest.mock import AsyncMock
+
+import pytest
+
+from frequenz.client.electricity_trading._backoff import Backoff
+
+
+@pytest.mark.asyncio
+async def test_successful_execution() -> None:
+    """Test that the backoff executes a successful call."""
+    backoff = Backoff(
+        initial_timeout=1.0,
+        max_timeout=10.0,
+        timeout_growth_factor=2.0,
+        max_retries=3,
+        reset_interval=600,
+    )
+    mock_call = AsyncMock(return_value="success")
+
+    result = await backoff.execute_with_backoff(mock_call)
+    assert result == "success"
+    mock_call.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_success_after_one_timeout() -> None:
+    """Test that the backoff retries once and then succeeds."""
+    backoff = Backoff(
+        initial_timeout=1.0,
+        max_timeout=10.0,
+        timeout_growth_factor=2.0,
+        max_retries=3,
+        reset_interval=600,
+    )
+    mock_call = AsyncMock(side_effect=[asyncio.TimeoutError, "success"])
+
+    result = await backoff.execute_with_backoff(mock_call)
+    assert result == "success"
+    assert mock_call.await_count == 2
+
+
+@pytest.mark.asyncio
+async def test_success_on_max_retries() -> None:
+    """Test that the backoff retries the maximum number of times and succeeds on the last one."""
+    backoff = Backoff(
+        initial_timeout=1.0,
+        max_timeout=10.0,
+        timeout_growth_factor=2.0,
+        max_retries=3,
+        reset_interval=600,
+    )
+    mock_call = AsyncMock(side_effect=[asyncio.TimeoutError] * 3 + ["success"])
+
+    result = await backoff.execute_with_backoff(mock_call)
+    assert result == "success"
+    assert mock_call.await_count == 4  # Initial call + 3 retries
+
+
+@pytest.mark.asyncio
+async def test_failure_after_max_retries() -> None:
+    """Test that the backoff retries the maximum number of times and fails."""
+    backoff = Backoff(
+        initial_timeout=1.0,
+        max_timeout=10.0,
+        timeout_growth_factor=2.0,
+        max_retries=3,
+        reset_interval=600,
+    )
+    mock_call = AsyncMock(side_effect=asyncio.TimeoutError)
+
+    with pytest.raises(asyncio.TimeoutError):
+        await backoff.execute_with_backoff(mock_call)
+
+    assert mock_call.await_count == 4  # Initial call + 3 retries
+
+
+@pytest.mark.asyncio
+async def test_timeout_increase() -> None:
+    """Test that the timeout increases with retries."""
+    backoff = Backoff(
+        initial_timeout=1.0,
+        max_timeout=10.0,
+        timeout_growth_factor=2.0,
+        max_retries=3,
+        reset_interval=600,
+    )
+    mock_call = AsyncMock(side_effect=asyncio.TimeoutError)
+
+    with pytest.raises(asyncio.TimeoutError):
+        await backoff.execute_with_backoff(mock_call)
+
+    # Initial timeout * (growth factor ** max_retries)
+    assert backoff._timeout == 8.0  # pylint: disable=protected-access
+
+
+@pytest.mark.asyncio
+async def test_invalid_growth_factor() -> None:
+    """Test that an invalid growth factor raises a ValueError."""
+    with pytest.raises(ValueError):
+        Backoff(
+            initial_timeout=1.0,
+            max_timeout=10.0,
+            timeout_growth_factor=0.5,  # Invalid
+            max_retries=3,
+            reset_interval=600,
+        )
+
+
+@pytest.mark.asyncio
+async def test_timeout_reset() -> None:
+    """Test that the timeout resets after successful execution."""
+    backoff = Backoff(
+        initial_timeout=1.0,
+        max_timeout=10.0,
+        timeout_growth_factor=2.0,
+        max_retries=3,
+        reset_interval=1,  # Short reset interval for testing
+    )
+
+    # First make it fail fully so that the timeout is increased
+    mock_call = AsyncMock(side_effect=asyncio.TimeoutError)
+    with pytest.raises(asyncio.TimeoutError):
+        await backoff.execute_with_backoff(mock_call)
+
+    # Wait until the reset interval has passed
+    await asyncio.sleep(1.5)
+
+    # Make a second attempt that succeeds
+    mock_call = AsyncMock(return_value="success")
+    await backoff.execute_with_backoff(mock_call)
+
+    # Check that the timeout was resetted
+    assert (
+        backoff._timeout == backoff._initial_timeout  # pylint: disable=protected-access
+    )
+
+
+@pytest.mark.asyncio
+async def test_zero_reset_interval() -> None:
+    """Test that the timeout does not reset if the reset interval is 0."""
+    backoff = Backoff(
+        initial_timeout=1.0,
+        max_timeout=10.0,
+        timeout_growth_factor=2.0,
+        max_retries=3,
+        reset_interval=0,
+    )
+
+    # First make it fail fully so that the timeout is increased
+    mock_call = AsyncMock(side_effect=asyncio.TimeoutError)
+    with pytest.raises(asyncio.TimeoutError):
+        await backoff.execute_with_backoff(mock_call)
+
+    # Make a second attempt that succeeds
+    mock_call = AsyncMock(return_value="success")
+    await backoff.execute_with_backoff(mock_call)
+
+    # Check that the timeout did not reset
+    assert (
+        backoff._timeout > backoff._initial_timeout  # pylint: disable=protected-access
+    )
+
+
+def test_negative_reset_interval() -> None:
+    """Test that a negative reset interval raises a ValueError."""
+    with pytest.raises(ValueError):
+        Backoff(
+            initial_timeout=1.0,
+            max_timeout=10.0,
+            timeout_growth_factor=2.0,
+            max_retries=3,
+            reset_interval=-1,  # Invalid negative value
+        )
+
+
+@pytest.mark.asyncio
+async def test_max_timeout() -> None:
+    """Test that the timeout stops increasing after reaching max_timeout."""
+    backoff = Backoff(
+        initial_timeout=1.0,
+        max_timeout=8.0,  # Lower max_timeout for testing
+        timeout_growth_factor=2.0,
+        max_retries=5,
+        reset_interval=600,
+    )
+
+    # Simulate timeout error on every call
+    mock_call = AsyncMock(side_effect=asyncio.TimeoutError)
+    with pytest.raises(asyncio.TimeoutError):
+        await backoff.execute_with_backoff(mock_call)
+
+    assert backoff._timeout == backoff._max_timeout  # pylint: disable=protected-access
+
+
+@pytest.mark.asyncio
+async def test_initial_timeout_equals_max_timeout() -> None:
+    """Test that backoff works when initial_timeout equals max_timeout."""
+    backoff = Backoff(
+        initial_timeout=5.0,  # Same as max_timeout
+        max_timeout=5.0,
+        timeout_growth_factor=2.0,
+        max_retries=3,
+        reset_interval=600,
+    )
+
+    # Simulate timeout error on every call
+    mock_call = AsyncMock(side_effect=asyncio.TimeoutError)
+    with pytest.raises(asyncio.TimeoutError):
+        await backoff.execute_with_backoff(mock_call)
+
+    assert backoff._timeout == 5.0  # pylint: disable=protected-access
+    assert mock_call.await_count == 4  # Initial call + 3 retries