PyPI - celine-sdk - Versions diffs - 2.2.0__tar.gz → 2.2.1__tar.gz - Mend

Files changed (761) hide show

celine_sdk-2.2.1/tests/test_flexibility.py ADDED Viewed

@@ -0,0 +1,140 @@
+"""Tests for `celine.sdk.flexibility`.
+The seam is `mock_http`: the generated client builds its own `httpx.AsyncClient`,
+so the class is what gets replaced, and the wrapper runs against real responses.
+What is pinned here is the commitments export, the one call a mirror flow makes.
+On that route an empty list is a *meaningful* answer — "no commitment since that
+date" — so a refused or unreadable answer must not look like one: a mirror that
+receives `[]` for a `403` completes, writes nothing, and reports success.
+"""
+from __future__ import annotations
+from datetime import datetime, timezone
+import httpx
+import pytest
+from celine.sdk.flexibility import FlexibilityAdminClient, FlexibilityApiError
+from celine.sdk.flexibility.errors import FlexibilityApiError as _FromErrors
+pytestmark = pytest.mark.asyncio
+TOKEN = "tok-example-service-secret"
+BODY_MARKER = "example-body-secret"
+COMMITMENT = {
+    "id": "00000000-0000-4000-8000-000000000001",
+    "user_id": "example-user",
+    "suggestion_id": "example-suggestion",
+    "suggestion_type": "shift-consumption",
+    "community_id": "example-community",
+    "device_id": None,
+    "period_start": "2026-07-01T10:00:00+00:00",
+    "period_end": "2026-07-01T12:00:00+00:00",
+    "committed_at": "2026-06-30T09:00:00+00:00",
+    "reminded_at": None,
+    "settled_at": None,
+    "reward_points_estimated": 10,
+    "reward_points_actual": None,
+    "status": "committed",
+}
+def _admin() -> FlexibilityAdminClient:
+    return FlexibilityAdminClient("http://flexibility.test", default_token=TOKEN)
+def _answer(code: int, **kwargs):
+    def handle(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(code, **kwargs)
+    return handle
+class TestExportCommitmentsAnswers:
+    # @verifies REQ-0210
+    async def test_a_list_comes_back_as_schemas(self, mock_http):
+        seen = mock_http(_answer(200, json=[COMMITMENT]))
+        rows = await _admin().export_commitments(
+            created_after=datetime(2026, 6, 1, tzinfo=timezone.utc)
+        )
+        assert [str(r.id) for r in rows] == [COMMITMENT["id"]]
+        assert rows[0].user_id == "example-user"
+        assert seen[0].url.path == "/api/commitments/export"
+        assert seen[0].url.params["created_after"].startswith("2026-06-01T00:00:00")
+        assert seen[0].headers["authorization"] == f"Bearer {TOKEN}"
+    # @verifies REQ-0210
+    async def test_an_empty_list_is_an_empty_result(self, mock_http):
+        mock_http(_answer(200, json=[]))
+        assert await _admin().export_commitments() == []
+class TestExportCommitmentsRefusals:
+    # @verifies REQ-0210
+    @pytest.mark.parametrize("status", [401, 403, 404, 422, 500, 503])
+    async def test_a_non_2xx_raises_with_its_status(self, mock_http, status):
+        mock_http(_answer(status, json={"detail": BODY_MARKER}))
+        with pytest.raises(FlexibilityApiError) as caught:
+            await _admin().export_commitments()
+        assert caught.value.status_code == status
+        assert str(status) in str(caught.value)
+    # @verifies REQ-0210
+    async def test_a_proxy_page_raises_rather_than_failing_to_decode(self, mock_http):
+        mock_http(_answer(502, text=f"<html>{BODY_MARKER}</html>"))
+        with pytest.raises(FlexibilityApiError) as caught:
+            await _admin().export_commitments()
+        assert caught.value.status_code == 502
+    # @verifies REQ-0210
+    @pytest.mark.parametrize("status", [403, 500])
+    async def test_the_message_carries_no_token_and_no_body(self, mock_http, status):
+        mock_http(_answer(status, json={"detail": BODY_MARKER, "token": TOKEN}))
+        with pytest.raises(FlexibilityApiError) as caught:
+            await _admin().export_commitments()
+        rendered = str(caught.value) + repr(caught.value)
+        assert TOKEN not in rendered
+        assert BODY_MARKER not in rendered
+        # Nothing chained underneath carries the body into a traceback either.
+        assert caught.value.__cause__ is None
+        assert caught.value.__suppress_context__ or caught.value.__context__ is None
+class TestExportCommitmentsUnreadable:
+    # @verifies REQ-0210
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            {"json": None},
+            {"json": {"items": [COMMITMENT]}},
+            {"text": "not json"},
+            {"json": [{"id": "not-a-commitment"}]},
+        ],
+        ids=["null", "object", "not-json", "malformed-item"],
+    )
+    async def test_a_200_that_is_not_a_list_of_commitments_raises(
+        self, mock_http, kwargs
+    ):
+        mock_http(_answer(200, **kwargs))
+        with pytest.raises(FlexibilityApiError) as caught:
+            await _admin().export_commitments()
+        assert caught.value.status_code == 200
+        assert TOKEN not in str(caught.value)
+async def test_the_error_is_importable_without_the_client():
+    assert FlexibilityApiError is _FromErrors

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celine-sdk
-Version: 2.2.0
+Version: 2.2.1
 Summary: CELINE SDK
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

@@ -1,6 +1,6 @@
 [project]
 name = "celine-sdk"
-version = "2.2.0"
+version = "2.2.1"
 description = "CELINE SDK"
 readme = "README.md"
 requires-python = ">=3.10"

@@ -0,0 +1,4 @@
+from celine.sdk.flexibility.client import FlexibilityAdminClient, FlexibilityClient
+from celine.sdk.flexibility.errors import FlexibilityApiError
+__all__ = ["FlexibilityClient", "FlexibilityAdminClient", "FlexibilityApiError"]

@@ -26,12 +26,14 @@ Example — service account:
 from __future__ import annotations
 from datetime import datetime
+from http import HTTPStatus
 from typing import Optional
 from uuid import UUID
 import httpx
 from celine.sdk.auth import TokenProvider
+from celine.sdk.flexibility.errors import FlexibilityApiError
 from celine.sdk.openapi.flexibility import AuthenticatedClient
 from celine.sdk.openapi.flexibility.api.commitments import (
     cancel_commitment_api_commitments_commitment_id_delete,
@@ -59,7 +61,40 @@ from celine.sdk.openapi.flexibility.schemas import (
 )
 from celine.sdk.openapi.flexibility.types import UNSET
-__all__ = ["FlexibilityClient", "FlexibilityAdminClient"]
+__all__ = ["FlexibilityClient", "FlexibilityAdminClient", "FlexibilityApiError"]
+def _commitments(response: httpx.Response, what: str) -> list[CommitmentOutSchema]:
+    """A `200` list of commitments as schemas; anything else raises.
+    On the export route an empty list is a meaningful answer, so a refusal or an
+    unreadable body must not degrade to one: a mirror would complete having
+    fetched nothing. The error names the call and the status only; the body
+    stays on `FlexibilityApiError.body` and out of the message.
+    """
+    if response.status_code != HTTPStatus.OK:
+        raise FlexibilityApiError(
+            f"{what} refused: flexibility-api answered {response.status_code}",
+            status_code=response.status_code,
+            body=response.content,
+        )
+    unreadable = FlexibilityApiError(
+        f"{what}: flexibility-api answered 200 with no readable commitment list",
+        status_code=response.status_code,
+        body=response.content,
+    )
+    try:
+        payload = response.json()
+    except ValueError:
+        # `from None`: the decode error would repeat the body.
+        raise unreadable from None
+    if not isinstance(payload, list):
+        raise unreadable
+    try:
+        return [CommitmentOutSchema.model_validate(item) for item in payload]
+    except ValueError:
+        # `from None`: the validation error would repeat the body's values.
+        raise unreadable from None
 class FlexibilityClient:
@@ -249,15 +284,26 @@ class FlexibilityAdminClient:
         Args:
             created_after: Only return commitments created at or after this datetime.
                            Pass now() - 90 days for the standard mirror window.
+        Returns:
+            The commitments, possibly none: `[]` means only that the service
+            answered `200` with an empty list.
+        Raises:
+            FlexibilityApiError: on any status but `200`, and on a `200` whose
+                body is not a list of commitments. The message carries the
+                status code only, never the token or the body (REQ-0210).
         """
         client = await self._get_client(token)
-        res = await export_commitments_api_commitments_export_get.asyncio_detailed(
-            client=client,
+        # The request is built by the generated module (`_get_kwargs`), so path
+        # and query stay generated; the answer is read here. The generated
+        # parser raises `UnexpectedStatus` with the whole body in its message
+        # and fails with a decode error on a proxy's HTML page.
+        kwargs = export_commitments_api_commitments_export_get._get_kwargs(
             created_after=created_after if created_after is not None else UNSET,
         )
-        if not res.parsed:
-            return []
-        return [CommitmentOutSchema.model_validate(item.to_dict()) for item in res.parsed]
+        response = await client.get_async_httpx_client().request(**kwargs)
+        return _commitments(response, "export_commitments")
     async def get_pending_commitments(
         self, *, token: Optional[str] = None

@@ -0,0 +1,36 @@
+"""Errors raised by the Flexibility wrapper.
+Separate from `client.py` so a caller can catch the error without importing the
+client — the same shape as `celine.sdk.rec_registry.errors.RecRegistryApiError`,
+which this mirrors.
+"""
+from __future__ import annotations
+class FlexibilityApiError(RuntimeError):
+    """The Flexibility API refused or failed a request.
+    The message names the call and the status code only. The response body is
+    kept on :attr:`body` for a caller that wants to inspect it, and is never
+    written into the message, so logging the exception cannot leak what the
+    service echoed back.
+    Attributes:
+        status_code: The HTTP status the service answered, `200` for an answer
+            that could not be read as the documented shape.
+        body: The raw response body, as bytes.
+    """
+    def __init__(
+        self,
+        message: str,
+        status_code: int | None = None,
+        body: object | None = None,
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.args[0]!r}, status_code={self.status_code!r})"

@@ -30,6 +30,7 @@ src/celine/sdk/dt/participant.py
 src/celine/sdk/dt/util.py
 src/celine/sdk/flexibility/__init__.py
 src/celine/sdk/flexibility/client.py
+src/celine/sdk/flexibility/errors.py
 src/celine/sdk/nudging/__init__.py
 src/celine/sdk/nudging/client.py
 src/celine/sdk/onboarding/__init__.py
@@ -743,6 +744,7 @@ tests/test_broker.py
 tests/test_broker_token_scope.py
 tests/test_consumer_impact.py
 tests/test_dt.py
+tests/test_flexibility.py
 tests/test_jwt.py
 tests/test_jwt_algorithms.py
 tests/test_logging.py

celine-sdk 2.2.0__tar.gz → 2.2.1__tar.gz

celine-sdk 2.2.0tar.gz → 2.2.1tar.gz