flowent 0.0.0 → 0.0.4

package/backend/tests/unit/providers/test_anthropic_provider.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from typing import Any, Literal
+
+import pytest
+
+from flowent.providers.anthropic import AnthropicProvider
+from flowent.providers.errors import LLMProviderError
+
+
+class _FakeStreamResponse:
+    def __init__(
+        self,
+        *,
+        lines: list[str],
+        status_code: int = 200,
+        headers: dict[str, str] | None = None,
+        text: str = "",
+        content_chunks: list[bytes | str] | None = None,
+    ) -> None:
+        self._lines = lines
+        self.status_code = status_code
+        self.headers = headers or {}
+        self.text = text
+        self._content_chunks = content_chunks or []
+
+    def __enter__(self) -> _FakeStreamResponse:
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> Literal[False]:
+        return False
+
+    def close(self) -> None:
+        return None
+
+    def iter_lines(self) -> Iterator[str]:
+        return iter(self._lines)
+
+    def iter_content(self) -> Iterator[bytes | str]:
+        return iter(self._content_chunks)
+
+    def read(self) -> bytes:
+        return b""
+
+
+class _FakeJsonResponse:
+    def __init__(
+        self,
+        payload: dict[str, Any] | None = None,
+        status_code: int = 200,
+    ) -> None:
+        self._payload = payload or {}
+        self.status_code = status_code
+
+    def raise_for_status(self) -> None:
+        if self.status_code >= 400:
+            raise RuntimeError(f"status {self.status_code}")
+
+    def json(self) -> dict[str, Any]:
+        return self._payload
+
+
+class _FakeClient:
+    def __init__(
+        self,
+        *,
+        responses: list[_FakeStreamResponse] | None = None,
+        json_payload: dict[str, Any] | None = None,
+        status_code: int = 200,
+    ) -> None:
+        self._responses = responses or []
+        self._json_payload = json_payload or {}
+        self._status_code = status_code
+        self.last_stream_url: str | None = None
+        self.last_get_url: str | None = None
+        self.last_headers: dict[str, str] | None = None
+        self.last_payload: dict[str, Any] | None = None
+
+    def stream(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        json: dict[str, Any],
+    ) -> _FakeStreamResponse:
+        self.last_stream_url = url
+        self.last_headers = headers
+        self.last_payload = json
+        return self._responses.pop(0)
+
+    def get(self, url: str, headers: dict[str, str]) -> _FakeJsonResponse:
+        self.last_get_url = url
+        self.last_headers = headers
+        return _FakeJsonResponse(
+            payload=self._json_payload,
+            status_code=self._status_code,
+        )
+
+    def close(self) -> None:
+        return None
+
+
+def _make_data_lines(*events: dict[str, Any]) -> list[str]:
+    return [f"data: {json.dumps(event)}" for event in events]
+
+
+def test_anthropic_chat_uses_resolved_base_url_without_duplicate_v1():
+    provider = AnthropicProvider(
+        provider_name="Test Provider",
+        api_base_url="http://example.invalid/v1",
+        api_key="secret",
+        headers={"x-api-key": "override", "X-Test": "value"},
+        model="claude-3-7-sonnet",
+    )
+    client = _FakeClient(
+        responses=[
+            _FakeStreamResponse(
+                lines=_make_data_lines(
+                    {
+                        "type": "content_block_delta",
+                        "delta": {"type": "text_delta", "text": "Hello"},
+                    },
+                    {"type": "message_stop"},
+                )
+            )
+        ]
+    )
+    provider._client = client
+
+    response = provider.chat(messages=[{"role": "user", "content": "Say hi"}])
+
+    assert client.last_stream_url == "http://example.invalid/v1/messages"
+    assert response.content == "Hello"
+    assert client.last_headers == {
+        "Content-Type": "application/json",
+        "x-api-key": "override",
+        "anthropic-version": "2023-06-01",
+        "X-Test": "value",
+    }
+
+
+def test_anthropic_list_models_uses_resolved_base_url_without_duplicate_v1():
+    provider = AnthropicProvider(
+        provider_name="Test Provider",
+        api_base_url="http://example.invalid/v1",
+        api_key="secret",
+        model="claude-3-7-sonnet",
+    )
+    client = _FakeClient(
+        json_payload={"data": [{"id": "claude-3-7-sonnet"}]},
+    )
+    provider._client = client
+
+    models = provider.list_models()
+
+    assert client.last_get_url == "http://example.invalid/v1/models"
+    assert [model.id for model in models] == ["claude-3-7-sonnet"]
+
+
+def test_anthropic_chat_surfaces_status_error_detail_without_duplicate_v1():
+    provider = AnthropicProvider(
+        provider_name="Test Provider",
+        api_base_url="http://example.invalid/v1",
+        api_key="secret",
+        model="claude-3-7-sonnet",
+    )
+    client = _FakeClient(
+        responses=[
+            _FakeStreamResponse(
+                lines=[],
+                status_code=404,
+                text='{"error":{"message":"Not found"}}',
+            )
+        ]
+    )
+    provider._client = client
+
+    with pytest.raises(LLMProviderError) as excinfo:
+        provider.chat(messages=[{"role": "user", "content": "Hello"}])
+
+    assert client.last_stream_url == "http://example.invalid/v1/messages"
+    assert excinfo.value.status_code == 404
+    assert "Base URL: http://example.invalid/v1" in str(excinfo.value)

package/backend/tests/unit/providers/test_errors.py

@@ -0,0 +1,68 @@
+from flowent.providers.errors import (
+    build_access_blocked_error,
+    build_configuration_error,
+    build_network_error,
+    build_status_error,
+)
+
+
+class ConnectTimeoutError(Exception):
+    pass
+
+
+def test_build_status_error_extracts_brief_json_detail():
+    error = build_status_error(
+        provider_name="Test Provider",
+        provider_type="openai",
+        model="gpt-5.2",
+        base_url="http://example.invalid",
+        status_code=401,
+        body='{"error":{"message":"Invalid API key provided","type":"invalid_request_error"}}',
+    )
+
+    assert "Detail: Invalid API key provided" in str(error)
+    assert '"invalid_request_error"' not in str(error)
+    assert '{"error"' not in str(error)
+
+
+def test_build_network_error_omits_local_exception_class_name():
+    error = build_network_error(
+        provider_name="Test Provider",
+        provider_type="openai",
+        model="gpt-5.2",
+        base_url="http://example.invalid",
+        error=ConnectTimeoutError("Connection timed out while contacting upstream"),
+    )
+
+    assert "Error: Connection timed out while contacting upstream" in str(error)
+    assert "ConnectTimeoutError" not in str(error)
+
+
+def test_build_access_blocked_error_hides_html_body():
+    error = build_access_blocked_error(
+        provider_name="Test Provider",
+        provider_type="openai",
+        model="gpt-5.2",
+        base_url="http://example.invalid",
+        status_code=403,
+        detail="<title>Just a moment...</title>",
+    )
+
+    assert "LLM API access blocked" in str(error)
+    assert "Status: 403" in str(error)
+    assert "Detail: Challenge or interstitial HTML response from upstream" in str(error)
+    assert "<title>" not in str(error)
+
+
+def test_build_configuration_error_formats_local_validation_failure():
+    error = build_configuration_error(
+        provider_name="Test Provider",
+        provider_type="openai_responses",
+        model="",
+        base_url="http://example.invalid",
+        detail="No active model configured",
+    )
+
+    assert "LLM configuration error" in str(error)
+    assert "Detail: No active model configured" in str(error)
+    assert error.transient is False

package/backend/tests/unit/providers/test_extract_delta_parts.py

@@ -0,0 +1,22 @@
+from flowent.providers.openai import _extract_delta_parts
+
+
+def test_reasoning_field():
+    delta = {"reasoning_content": "thinking..."}
+    content, thinking = _extract_delta_parts(delta)
+    assert content is None
+    assert thinking == "thinking..."
+
+
+def test_content_field():
+    delta = {"content": "answer"}
+    content, thinking = _extract_delta_parts(delta)
+    assert content == "answer"
+    assert thinking is None
+
+
+def test_both_fields():
+    delta = {"reasoning_content": "thinking", "content": "answer"}
+    content, thinking = _extract_delta_parts(delta)
+    assert content == "answer"
+    assert thinking == "thinking"

package/backend/tests/unit/providers/test_openai_provider.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from typing import Any, Literal
+
+from flowent.providers.openai import OpenAIProvider
+
+
+class _FakeStreamResponse:
+    def __init__(
+        self,
+        *,
+        lines: list[str],
+        status_code: int = 200,
+        headers: dict[str, str] | None = None,
+        text: str = "",
+        content_chunks: list[bytes | str] | None = None,
+    ) -> None:
+        self._lines = lines
+        self.status_code = status_code
+        self.headers = headers or {}
+        self.text = text
+        self._content_chunks = content_chunks or []
+
+    def __enter__(self) -> _FakeStreamResponse:
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> Literal[False]:
+        return False
+
+    def iter_lines(self) -> Iterator[str]:
+        return iter(self._lines)
+
+    def iter_content(self) -> Iterator[bytes | str]:
+        return iter(self._content_chunks)
+
+    def read(self) -> bytes:
+        return b""
+
+
+class _FakeClient:
+    def __init__(self, responses: list[_FakeStreamResponse]) -> None:
+        self._responses = responses
+        self.payloads: list[dict[str, Any]] = []
+
+    def stream(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        json: dict[str, Any],
+    ) -> _FakeStreamResponse:
+        self.payloads.append(json)
+        return self._responses.pop(0)
+
+    def close(self) -> None:
+        return None
+
+
+def _make_data_lines(*events: dict[str, Any]) -> list[str]:
+    return [f"data: {json.dumps(event)}" for event in events]
+
+
+def test_openai_chat_requests_stream_usage_and_returns_usage():
+    provider = OpenAIProvider(
+        provider_name="Test Provider",
+        api_base_url="http://example.invalid",
+        api_key="secret",
+        model="gpt-4.1",
+    )
+    client = _FakeClient(
+        [
+            _FakeStreamResponse(
+                lines=_make_data_lines(
+                    {"choices": [{"delta": {"content": "Hello"}}]},
+                    {
+                        "choices": [],
+                        "usage": {
+                            "total_tokens": 21,
+                            "prompt_tokens": 13,
+                            "completion_tokens": 8,
+                            "prompt_tokens_details": {"cached_tokens": 5},
+                        },
+                    },
+                )
+            )
+        ]
+    )
+    provider._client = client
+
+    response = provider.chat(messages=[{"role": "user", "content": "Say hi"}])
+
+    assert client.payloads[0]["stream_options"] == {"include_usage": True}
+    assert response.content == "Hello"
+    assert response.usage is not None
+    assert response.usage.total_tokens == 21
+    assert response.usage.input_tokens == 13
+    assert response.usage.output_tokens == 8
+    assert response.usage.cached_input_tokens == 5
+    assert response.usage.cache_read_tokens == 5
+    assert response.raw_usage == {
+        "total_tokens": 21,
+        "prompt_tokens": 13,
+        "completion_tokens": 8,
+        "prompt_tokens_details": {"cached_tokens": 5},
+    }
+
+
+def test_openai_chat_retries_without_stream_usage_when_provider_rejects_it():
+    provider = OpenAIProvider(
+        provider_name="Test Provider",
+        api_base_url="http://example.invalid",
+        api_key="secret",
+        model="gpt-4.1",
+    )
+    client = _FakeClient(
+        [
+            _FakeStreamResponse(
+                lines=[],
+                status_code=400,
+                text='{"error":{"message":"Unknown field: stream_options"}}',
+            ),
+            _FakeStreamResponse(
+                lines=_make_data_lines(
+                    {"choices": [{"delta": {"content": "Recovered"}}]}
+                )
+            ),
+        ]
+    )
+    provider._client = client
+
+    response = provider.chat(messages=[{"role": "user", "content": "Say hi"}])
+
+    assert client.payloads[0]["stream_options"] == {"include_usage": True}
+    assert "stream_options" not in client.payloads[1]
+    assert response.content == "Recovered"
+    assert response.usage is None
+    assert response.raw_usage is None