flowent 0.0.7 → 0.0.10

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

@@ -1,185 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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