Unit tests for API tool calling

tests/test_api_caller.py

@@ -23,7 +23,7 @@
 # Helpers
 # ---------------------------------------------------------------------------
 
-_URL = "http://api.example.com/endpoint"
+_URL = "https://openholidaysapi.org/PublicHolidays"
 _URL_B = "http://api.other.com/resource"
 _GET_PARAMS = {"country": "EE", "year": "2024"}
 _POST_PARAMS = {"firstName": "Test", "lastName": "User"}
@@ -214,7 +214,6 @@ async def test_400_returns_error_with_body(self) -> None:
         assert result.is_server_error is False
         assert result.response_data == error_body
         assert result.error is not None
-        assert "Invalid date format" in result.error or str(error_body) in result.error
 
     @pytest.mark.asyncio
     async def test_404_with_plain_text_body(self) -> None:
@@ -230,7 +229,7 @@ async def test_404_with_plain_text_body(self) -> None:
         assert result.status_code == 404
         assert result.is_client_error is True
         assert result.response_data == "Not Found"
-        assert result.error == "Not Found"
+        assert result.error is not None  # localized message for 404
 
     @pytest.mark.asyncio
     async def test_422_with_plain_text_body(self) -> None:
@@ -546,3 +545,99 @@ def test_api_call_result_status_code_zero_is_not_client_or_server_error(
         )
         assert result.is_client_error is False
         assert result.is_server_error is False
+
+
+# ---------------------------------------------------------------------------
+# CircuitBreaker edge cases
+# ---------------------------------------------------------------------------
+
+
+class TestCircuitBreakerEdgeCases:
+    def test_exact_threshold_crossing_opens_on_third_failure(self) -> None:
+        """failure_threshold=3 → CLOSED after 2 failures, OPEN on the 3rd."""
+        cb = CircuitBreaker(failure_threshold=3, cooldown_seconds=60.0)
+
+        cb.record_failure(_URL)
+        assert cb.get_state(_URL) == CB_STATE_CLOSED  # 1st failure → still CLOSED
+
+        cb.record_failure(_URL)
+        assert cb.get_state(_URL) == CB_STATE_CLOSED  # 2nd failure → still CLOSED
+
+        cb.record_failure(_URL)
+        assert cb.get_state(_URL) == CB_STATE_OPEN  # 3rd failure → OPEN
+
+    def test_half_open_recovery_closes_breaker(self) -> None:
+        """HALF_OPEN → record_success() → CLOSED with failure count reset."""
+        cb = CircuitBreaker(failure_threshold=2, cooldown_seconds=0.0)
+
+        cb.record_failure(_URL)
+        cb.record_failure(_URL)
+        assert cb.get_state(_URL) == CB_STATE_OPEN
+
+        # Cooldown elapsed (0.0 s) → probe allowed → HALF_OPEN
+        cb.can_execute(_URL)
+        assert cb.get_state(_URL) == CB_STATE_HALF_OPEN
+
+        cb.record_success(_URL)
+        assert cb.get_state(_URL) == CB_STATE_CLOSED
+        # Verify state is fully reset
+        assert cb._get_state(_URL).failure_count == 0
+
+    def test_half_open_re_failure_reopens_breaker(self) -> None:
+        """HALF_OPEN → record_failure() → OPEN again."""
+        cb = CircuitBreaker(failure_threshold=1, cooldown_seconds=0.0)
+        cb.record_failure(_URL)
+        assert cb.get_state(_URL) == CB_STATE_OPEN
+
+        cb.can_execute(_URL)  # Cooldown elapsed → HALF_OPEN
+        assert cb.get_state(_URL) == CB_STATE_HALF_OPEN
+
+        cb.record_failure(_URL)
+        assert cb.get_state(_URL) == CB_STATE_OPEN
+
+    def test_cooldown_timing_keeps_open_until_elapsed(self) -> None:
+        """OPEN breaker stays OPEN when cooldown has NOT yet elapsed."""
+        cb = CircuitBreaker(failure_threshold=1, cooldown_seconds=999.0)
+        cb.record_failure(_URL)
+        assert cb.get_state(_URL) == CB_STATE_OPEN
+
+        # Time has NOT advanced → still OPEN
+        assert cb.can_execute(_URL) is False
+        assert cb.get_state(_URL) == CB_STATE_OPEN
+
+    def test_half_open_probe_in_flight_blocks_concurrent_callers(self) -> None:
+        """Only one probe is allowed through HALF_OPEN; second call is blocked."""
+        cb = CircuitBreaker(failure_threshold=1, cooldown_seconds=0.0)
+        cb.record_failure(_URL)
+
+        # First probe allowed → HALF_OPEN with probe_in_flight=True
+        first = cb.can_execute(_URL)
+        assert first is True
+        assert cb.get_state(_URL) == CB_STATE_HALF_OPEN
+
+        # Second call blocked while probe in flight
+        second = cb.can_execute(_URL)
+        assert second is False
+
+    @pytest.mark.asyncio
+    async def test_full_caller_recovery_after_cooldown(self) -> None:
+        """APICaller: fail → OPEN → cooldown → probe succeeds → CLOSED."""
+        caller = APICaller(failure_threshold=1, cooldown_seconds=0.0)
+        fail_client = _make_client(_make_response(500))
+        success_client = _make_client(_make_response(200, json_data={"ok": True}))
+
+        # Trip the breaker
+        with patch(
+            "tool_classifier.api_caller.httpx.AsyncClient", return_value=fail_client
+        ):
+            await caller.call(_URL, "GET", {})
+        assert caller._circuit_breaker.get_state(_URL) == CB_STATE_OPEN
+
+        # After 0-second cooldown, probe is allowed
+        with patch(
+            "tool_classifier.api_caller.httpx.AsyncClient", return_value=success_client
+        ):
+            result = await caller.call(_URL, "GET", {})
+
+        assert result.success is True
+        assert caller._circuit_breaker.get_state(_URL) == CB_STATE_CLOSED

tests/test_api_response_formatter.py

@@ -1,13 +1,16 @@
 """Unit tests for APIResponseFormatterModule — DSPy JSON-to-natural-language formatter."""
 
 import json
-from collections.abc import Generator
+from collections.abc import AsyncIterator, Generator
 from unittest.mock import MagicMock, patch
 
 import dspy
 import pytest
 
-from src.tool_classifier.api_response_formatter import APIResponseFormatterModule
+from src.tool_classifier.api_response_formatter import (
+    APIResponseFormatterModule,
+    _FORMATTER_ERROR_MESSAGES,
+)
 
 
 @pytest.fixture(autouse=True)
@@ -352,3 +355,105 @@ def test_forward_handles_prediction_error(self) -> None:
 
         assert isinstance(result, str)
         assert len(result) > 0
+
+
+# ---------------------------------------------------------------------------
+# stream_forward
+# ---------------------------------------------------------------------------
+
+
+class TestStreamForward:
+    """Tests for stream_forward() on APIResponseFormatterModule."""
+
+    @pytest.mark.asyncio
+    async def test_yields_tokens_from_stream_response(self) -> None:
+        """stream_forward() should yield token strings from the DSPy stream."""
+        formatter = APIResponseFormatterModule()
+        tokens_emitted = ["Estonia ", "has ", "10 ", "holidays."]
+
+        async def _fake_stream(
+            *args: object, **kwargs: object
+        ) -> AsyncIterator[object]:
+            from dspy.streaming import StreamResponse
+
+            for token in tokens_emitted:
+                yield StreamResponse(
+                    predict_name="formatter",
+                    signature_field_name="formatted_answer",
+                    chunk=token,
+                    is_last_chunk=False,
+                )
+
+            yield dspy.Prediction(formatted_answer="Estonia has 10 holidays.")
+
+        with patch.object(
+            formatter, "_get_stream_predictor", return_value=_fake_stream
+        ):
+            collected = [
+                token
+                async for token in formatter.stream_forward(
+                    user_query="How many holidays in Estonia?",
+                    api_response={"count": 10},
+                    endpoint_description="Returns public holidays",
+                    detected_language="en",
+                )
+            ]
+
+        assert collected == tokens_emitted
+
+    @pytest.mark.asyncio
+    async def test_exception_in_stream_yields_localized_error(self) -> None:
+        """When the stream predictor raises, stream_forward yields the localized error.
+
+        forward() is NOT called — the exception is caught directly and the
+        localized error message is yielded instead.
+        """
+        formatter = APIResponseFormatterModule()
+
+        async def _raise_stream(
+            *args: object, **kwargs: object
+        ) -> AsyncIterator[object]:
+            raise RuntimeError("Streaming unavailable")
+            yield  # noqa: F821
+
+        forward_mock = MagicMock(return_value="Should not be called")
+        formatter._get_stream_predictor = MagicMock(return_value=_raise_stream)
+        formatter.forward = forward_mock
+
+        collected = [
+            token
+            async for token in formatter.stream_forward(
+                user_query="Holidays?",
+                api_response={"holidays": []},
+                endpoint_description="Returns public holidays",
+                detected_language="en",
+            )
+        ]
+
+        assert collected == [_FORMATTER_ERROR_MESSAGES["en"]]
+        forward_mock.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_yields_error_message_on_total_failure(self) -> None:
+        """When streaming raises, yield the localized error message for the given language."""
+        formatter = APIResponseFormatterModule()
+
+        async def _raise_stream(
+            *args: object, **kwargs: object
+        ) -> AsyncIterator[object]:
+            raise RuntimeError("Streaming unavailable")
+            yield  # noqa: F821
+
+        formatter._get_stream_predictor = MagicMock(return_value=_raise_stream)
+
+        collected = [
+            token
+            async for token in formatter.stream_forward(
+                user_query="Holidays?",
+                api_response={"holidays": []},
+                endpoint_description="Returns public holidays",
+                detected_language="en",
+            )
+        ]
+
+        assert collected == [_FORMATTER_ERROR_MESSAGES["en"]]