From 01c2e9561daf18a17b88e1a3461caa8e7c139913 Mon Sep 17 00:00:00 2001 From: Lemuel Boyce Date: Sat, 14 Nov 2026 00:19:43 -0500 Subject: [PATCH 1/2] =?UTF-8?q?Fix=20Mop=C3=A9=20API=20routes,=20timeouts?= =?UTF-8?q?=20and=20error=20details=20for=200.3.1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 22 +++++++ mope/__version__.py | 2 +- mope/client.py | 40 +++++++++++-- mope/errors.py | 52 ++++++++++++++++ mope/resources/shop.py | 5 +- tests/test_client.py | 77 ++++++++++++++++++++++++ tests/test_errors.py | 131 +++++++++++++++++++++++++++++++++++++++++ tests/test_mope.py | 21 +++++-- tests/typing.py | 22 ++++++- 9 files changed, 356 insertions(+), 16 deletions(-) create mode 100644 mope/errors.py create mode 100644 tests/test_client.py create mode 100644 tests/test_errors.py diff --git a/README.md b/README.md index 0b313ec..8ba53d8 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,28 @@ mope = Mope(token="test_123") mope.shop.get_payment_request(payment_id="123") ``` +### Timeouts and errors + +Requests use a 5-second connect timeout and a 30-second read timeout by default. +Configure both with `Mope(token="test_123", timeout=(3.0, 15.0))`, or pass a +single number of seconds to apply to both. `mope.client.Client` accepts the same +keyword argument. Values must be finite and greater than zero. The read timeout +limits inactivity between received bytes, not the total duration of a request. + +Shop methods raise `mope.errors.MopeAPIError` for HTTP errors. It is a subclass +of `requests.HTTPError`, so existing handlers keep working. Its `status_code`, +`code`, `message`, and `data` fields expose the HTTP status and validated Mopé +error details, such as code `1033` for account limits exceeded. If the error body +is missing or malformed, `code` and `data` are `None` and `message` retains the +HTTP error description. The original response and exception cause are preserved. + +Connection failures and timeouts remain `requests.RequestException` subclasses. +Malformed successful responses still raise `TypeError`, `ValueError`, or +`KeyError`; invalid JSON raises `requests.exceptions.JSONDecodeError`, which is +also a `ValueError`. Applications should translate these errors at the API call +boundary and decide which failures are retryable. Requests are not automatically +retried, including payment creation after a timeout. + ### Development Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then run: diff --git a/mope/__version__.py b/mope/__version__.py index ea8ab13..8c11926 100644 --- a/mope/__version__.py +++ b/mope/__version__.py @@ -1,2 +1,2 @@ __author__ = "lemuel@vokality.com" -__version__ = "0.3.0" +__version__ = "0.3.1" diff --git a/mope/client.py b/mope/client.py index 6bede4c..2d301e0 100644 --- a/mope/client.py +++ b/mope/client.py @@ -1,4 +1,5 @@ from collections.abc import Iterable, Mapping, Set +from math import isfinite from typing import IO, Protocol, TypeAlias from urllib.parse import urljoin @@ -29,19 +30,45 @@ def items(self) -> Set[tuple[QueryScalar, QueryValue]]: ... | str | bytes ) +RequestTimeout: TypeAlias = float | tuple[float, float] _user_agent = f"Python Mope {__version__}" +_BASE_URL = "https://api.mope.sr/api/" +_DEFAULT_TIMEOUT = (5.0, 30.0) + + +def _timeout_seconds(value: object) -> float: + if isinstance(value, bool) or not isinstance(value, (int, float)): + raise TypeError("timeout must contain numbers of seconds") + try: + seconds = float(value) + except OverflowError as error: + raise ValueError("timeout must be finite and greater than zero") from error + if not isfinite(seconds) or seconds <= 0: + raise ValueError("timeout must be finite and greater than zero") + return seconds + + +def _request_timeout(value: object) -> RequestTimeout: + if isinstance(value, tuple): + if len(value) != 2: + raise ValueError("timeout must be a (connect, read) pair") + return (_timeout_seconds(value[0]), _timeout_seconds(value[1])) + return _timeout_seconds(value) class Client: - def __init__(self, token: str) -> None: + def __init__( + self, token: str, *, timeout: RequestTimeout = _DEFAULT_TIMEOUT + ) -> None: + self._timeout = _request_timeout(timeout) self._token = token self._headers = { "User-Agent": _user_agent, "Content-Type": "application/json", "Authorization": f"Bearer {token}", } - self._base_url = "https://api.mope.sr/api" + self._base_url = _BASE_URL def call_api( self, @@ -59,20 +86,23 @@ def call_api( data=data, json=json_value(json, path="request"), headers=self._headers, + timeout=self._timeout, ) class Mope: - def __init__(self, token: str) -> None: + def __init__( + self, token: str, *, timeout: RequestTimeout = _DEFAULT_TIMEOUT + ) -> None: self._token = token self._headers = { "User-Agent": _user_agent, "Content-Type": "application/json", "Authorization": f"Bearer {token}", } - self.base_url = "https://api.mope.sr/api" + self.base_url = _BASE_URL - self._client = Client(token) + self._client = Client(token, timeout=timeout) self.shop = ShopResource(self._client) diff --git a/mope/errors.py b/mope/errors.py new file mode 100644 index 0000000..597aa3f --- /dev/null +++ b/mope/errors.py @@ -0,0 +1,52 @@ +"""Typed details for HTTP errors returned by the Mopé API.""" + +from typing import Self + +from requests import HTTPError, Response + +from mope.json import JsonValue, json_integer, json_object, json_string + + +class MopeAPIError(HTTPError): + """An HTTP rejection, with validated Mopé error details when available.""" + + response: Response | None + + def __init__( + self, + message: str, + *, + response: Response | None = None, + code: int | None = None, + data: JsonValue = None, + ) -> None: + super().__init__(message, response=response) + self.message = message + self.code = code + self.data = data + + @property + def status_code(self) -> int | None: + return self.response.status_code if self.response is not None else None + + @classmethod + def from_response(cls, response: Response, *, fallback_message: str) -> Self: + try: + payload = json_object(response.json()) + # The schema wraps details in "error"; documented examples are unwrapped. + details = json_object(payload.get("error", payload), path="error") + code = json_integer(details["code"], path="error.code") + message = json_string(details["message"], path="error.message") + except (TypeError, ValueError, KeyError): + return cls(fallback_message, response=response) + return cls(message, response=response, code=code, data=details.get("data")) + + +def raise_for_status(response: Response) -> None: + """Preserve HTTPError compatibility without letting a bad error body mask it.""" + try: + response.raise_for_status() + except HTTPError as error: + raise MopeAPIError.from_response( + response, fallback_message=str(error) + ) from error diff --git a/mope/resources/shop.py b/mope/resources/shop.py index 7186c03..38d4371 100644 --- a/mope/resources/shop.py +++ b/mope/resources/shop.py @@ -1,3 +1,4 @@ +from mope.errors import raise_for_status from mope.models.payments import CreatePaymentResponse, CurrencyCode, PaymentRequest from mope.transport import ApiTransport @@ -30,7 +31,7 @@ def create_payment_request( "redirect_url": redirect_url, }, ) - response.raise_for_status() + raise_for_status(response) return CreatePaymentResponse.from_json(response.json()) def get_payment_request(self, payment_id: str) -> PaymentRequest: @@ -40,5 +41,5 @@ def get_payment_request(self, payment_id: str) -> PaymentRequest: endpoint = f"shop/payment_request/{payment_id}" response = self._client.call_api("GET", endpoint=endpoint) - response.raise_for_status() + raise_for_status(response) return PaymentRequest.from_json(response.json()) diff --git a/tests/test_client.py b/tests/test_client.py new file mode 100644 index 0000000..98955eb --- /dev/null +++ b/tests/test_client.py @@ -0,0 +1,77 @@ +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from threading import Event, Thread +from unittest.mock import patch + +import pytest +from requests import ConnectionError, ReadTimeout, Timeout + +from mope.client import Client, Mope, RequestTimeout + + +@pytest.mark.parametrize("timeout", [2, 2.5, (1, 3), (1.5, 3.5)]) +def test_configured_timeout_reaches_transport(timeout: RequestTimeout) -> None: + with patch("requests.request") as request: + client = Client("token", timeout=timeout) + client.call_api("GET", "shop/payment_request/payment-123") + assert request.call_args.kwargs["timeout"] == timeout + assert request.call_args.kwargs["url"] == ( + "https://api.mope.sr/api/shop/payment_request/payment-123" + ) + + api = Mope("token", timeout=timeout) + request.return_value.json.return_value = { + "id": "payment-123", + "url": "https://mope.sr/p/payment-123", + } + api.shop.create_payment_request( + 100, "order", "order-1", "SRD", "https://example.com" + ) + assert request.call_args.kwargs["timeout"] == timeout + + +@pytest.mark.parametrize( + "timeout", [0.0, -1.0, float("inf"), float("nan"), (1.0, 0.0), (float("inf"), 2.0)] +) +@pytest.mark.parametrize("client_type", [Client, Mope]) +def test_non_positive_or_unbounded_timeout_is_rejected( + client_type: type[Client] | type[Mope], timeout: RequestTimeout +) -> None: + with pytest.raises(ValueError, match="finite and greater than zero"): + client_type("token", timeout=timeout) + + +@pytest.mark.parametrize( + "failure", [Timeout("timeout"), ConnectionError("connection failed")] +) +def test_network_errors_propagate_without_retry(failure: Exception) -> None: + with patch("requests.request", side_effect=failure) as request: + with pytest.raises(type(failure)) as raised: + Mope("token").shop.create_payment_request( + 100, "order", "order-1", "SRD", "https://example.com" + ) + assert raised.value is failure + request.assert_called_once() + + +def test_read_timeout_interrupts_a_stalled_http_response() -> None: + received = Event() + release = Event() + + class StalledHandler(BaseHTTPRequestHandler): + def do_GET(self) -> None: + received.set() + release.wait(timeout=5) + + with ThreadingHTTPServer(("127.0.0.1", 0), StalledHandler) as server: + worker = Thread(target=server.serve_forever) + worker.start() + try: + with pytest.raises(ReadTimeout): + Client("token", timeout=(1.0, 0.1)).call_api( + "GET", f"http://127.0.0.1:{server.server_port}/stalled" + ) + assert received.is_set() + finally: + release.set() + server.shutdown() + worker.join(timeout=5) diff --git a/tests/test_errors.py b/tests/test_errors.py new file mode 100644 index 0000000..d75b5e4 --- /dev/null +++ b/tests/test_errors.py @@ -0,0 +1,131 @@ +import json +import pickle +from unittest.mock import patch + +import pytest +from requests import HTTPError, Request, Response + +from mope.client import Mope +from mope.errors import MopeAPIError, raise_for_status +from mope.json import JsonObject + + +def error_response(body: bytes, status_code: int = 400) -> Response: + response = Response() + response.status_code = status_code + response.reason = "Bad Request" if status_code == 400 else "Service Unavailable" + response.url = "https://api.mope.sr/api/shop/payment_request" + response.request = Request("POST", response.url).prepare() + response._content = body + return response + + +@pytest.mark.parametrize("wrapped", [True, False]) +def test_api_error_exposes_validated_details_and_preserves_http_error( + wrapped: bool, +) -> None: + details: JsonObject = { + "code": 1033, + "message": "Account limits exceeded", + "data": {"limit": 100}, + } + payload: JsonObject = {"error": details} if wrapped else details + response = error_response(json.dumps(payload).encode()) + + with pytest.raises(HTTPError) as raised: + raise_for_status(response) + + error = raised.value + assert isinstance(error, MopeAPIError) + assert error.code == 1033 + assert error.message == "Account limits exceeded" + assert str(error) == "Account limits exceeded" + assert error.data == {"limit": 100} + assert error.status_code == 400 + assert error.response is response + assert error.request is response.request + assert isinstance(error.__cause__, HTTPError) + assert error.__cause__.response is response + + +@pytest.mark.parametrize( + "body", + [ + b"", + b"Service unavailable", + b"null", + b"[]", + b"{}", + b'{"error": null}', + b'{"error": {"code": "1033", "message": "Invalid code"}}', + b'{"error": {"code": true, "message": "Invalid code"}}', + b'{"error": {"code": 1033, "message": 42}}', + b'{"error": {"message": "Missing code"}}', + b'{"error": {"code": 1033}}', + b'{"error": {"code": 1033, "message": "Invalid data", "data": NaN}}', + ], +) +def test_bad_error_body_preserves_http_failure(body: bytes) -> None: + response = error_response(body, status_code=503) + + with pytest.raises(MopeAPIError) as raised: + raise_for_status(response) + + error = raised.value + assert error.status_code == 503 + assert error.code is None + assert error.data is None + assert "503" in error.message + assert "Service Unavailable" in error.message + assert error.response is response + assert isinstance(error.__cause__, HTTPError) + + +@pytest.mark.parametrize("create", [True, False]) +def test_shop_methods_raise_typed_api_errors(create: bool) -> None: + response = error_response( + b'{"error": {"code": 1033, "message": "Account limits exceeded"}}' + ) + with patch("requests.request", return_value=response): + with pytest.raises(MopeAPIError) as raised: + client = Mope("token") + if create: + client.shop.create_payment_request( + 100, "order", "order-1", "SRD", "https://example.com" + ) + else: + client.shop.get_payment_request("payment-123") + + assert raised.value.code == 1033 + + +@pytest.mark.parametrize( + "body, expected", + [ + (b"OK", ValueError), + (b"{}", KeyError), + (b'{"id": 1, "url": "https://mope.sr/p/1"}', TypeError), + ], +) +def test_invalid_success_response_keeps_validation_exceptions( + body: bytes, expected: type[Exception] +) -> None: + response = error_response(body, status_code=200) + with patch("requests.request", return_value=response): + with pytest.raises(expected): + Mope("token").shop.create_payment_request( + 100, "order", "order-1", "SRD", "https://example.com" + ) + + +def test_api_error_survives_serialization() -> None: + response = error_response( + b'{"error": {"code": 1033, "message": "Account limits exceeded", "data": null}}' + ) + error = MopeAPIError.from_response(response, fallback_message="HTTP error") + restored: object = pickle.loads(pickle.dumps(error)) + assert isinstance(restored, MopeAPIError) + assert restored.status_code == 400 + assert restored.code == 1033 + assert restored.message == "Account limits exceeded" + assert restored.data is None diff --git a/tests/test_mope.py b/tests/test_mope.py index 3d48050..858e6b3 100644 --- a/tests/test_mope.py +++ b/tests/test_mope.py @@ -31,16 +31,17 @@ def test_call_api(self, mock_request: Mock) -> None: expected_response = Response() mock_request.return_value = expected_response response = self.client.call_api( - "POST", "https://api.mope.sr/api", json={"amount": 1000} + "POST", "shop/payment_request", json={"amount": 1000} ) self.assertIs(response, expected_response) mock_request.assert_called_once_with( - url="https://api.mope.sr/api", + url="https://api.mope.sr/api/shop/payment_request", json={"amount": 1000}, data=None, method="POST", params=None, + timeout=(5.0, 30.0), headers={ "User-Agent": f"Python Mope {__version__}", "Content-Type": "application/json", @@ -64,9 +65,10 @@ def test_shop_create_payment_request(self, mock_request: Mock) -> None: self.assertEqual(response.as_dict(), payload) mock_request.assert_called_once_with( method="POST", - url="https://api.mope.sr/shop/payment_request", + url="https://api.mope.sr/api/shop/payment_request", params=None, data=None, + timeout=(5.0, 30.0), json={ "amount": 1000, "order_id": "test-1", @@ -94,6 +96,12 @@ def test_shop_get_payment_request(self, mock_request: Mock) -> None: self.assertTrue(isinstance(mock_response.currency, Currency)) self.assertEqual(mock_response.as_dict(), mock_payment_request) + self.assertEqual( + mock_request.call_args.kwargs["url"], + "https://api.mope.sr/api/shop/payment_request/" + "c43f24a3-df4f-43b7-9045-b454529369dc", + ) + self.assertEqual(mock_request.call_args.kwargs["timeout"], (5.0, 30.0)) @mock.patch("requests.request") def test_invalid_response_is_rejected(self, mock_request: Mock) -> None: @@ -114,7 +122,10 @@ def test_invalid_request_json_is_rejected(self, mock_request: Mock) -> None: @mock.patch("requests.request") def test_http_errors_are_raised_before_parsing(self, mock_request: Mock) -> None: - mock_request.return_value.raise_for_status.side_effect = HTTPError("Not found") + response = Response() + response.status_code = 404 + response._content = b'{"error": {"code": 1002, "message": "Not found"}}' + mock_request.return_value = response with self.assertRaises(HTTPError): self.mope.shop.get_payment_request("payment-123") @@ -122,5 +133,3 @@ def test_http_errors_are_raised_before_parsing(self, mock_request: Mock) -> None self.mope.shop.create_payment_request( 100, "order", "order-1", "SRD", "https://example.com" ) - - mock_request.return_value.json.assert_not_called() diff --git a/tests/typing.py b/tests/typing.py index 6a2a724..ed0c0a2 100644 --- a/tests/typing.py +++ b/tests/typing.py @@ -2,11 +2,12 @@ from typing import assert_type -from requests import Response +from requests import HTTPError, Response from mope import Mope from mope.client import Client -from mope.json import JsonObject +from mope.errors import MopeAPIError +from mope.json import JsonObject, JsonValue from mope.models.payments import ( CreatePaymentResponse, Currency, @@ -59,3 +60,20 @@ def check_transport_inputs( transport.call_api("POST", "endpoint", params=query, data=form, json=payload), Response, ) + + +def check_timeout_and_error_types(error: MopeAPIError, response: Response) -> None: + assert_type(Mope("token", timeout=10.0), Mope) + assert_type(Mope("token", timeout=(3.0, 15.0)), Mope) + assert_type(Client("token", timeout=10), Client) + assert_type(Client("token", timeout=(3, 15)), Client) + http_error: HTTPError = error + assert_type(http_error, MopeAPIError) + assert_type(error.status_code, int | None) + assert_type(error.code, int | None) + assert_type(error.message, str) + assert_type(error.data, JsonValue) + assert_type( + MopeAPIError.from_response(response, fallback_message="HTTP error"), + MopeAPIError, + ) From d4206a3881f871ab1bfe1236aa4ceb775ce08d83 Mon Sep 17 00:00:00 2001 From: Lemuel Boyce Date: Sat, 14 Nov 2026 00:24:51 -0500 Subject: [PATCH 2/2] Keep focused payment API regression tests --- tests/test_client.py | 77 ---------- tests/test_errors.py | 131 ----------------- tests/test_models.py | 167 ---------------------- tests/test_mope.py | 327 ++++++++++++++++++++++++++----------------- tests/typing.py | 67 ++------- 5 files changed, 211 insertions(+), 558 deletions(-) delete mode 100644 tests/test_client.py delete mode 100644 tests/test_errors.py delete mode 100644 tests/test_models.py diff --git a/tests/test_client.py b/tests/test_client.py deleted file mode 100644 index 98955eb..0000000 --- a/tests/test_client.py +++ /dev/null @@ -1,77 +0,0 @@ -from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer -from threading import Event, Thread -from unittest.mock import patch - -import pytest -from requests import ConnectionError, ReadTimeout, Timeout - -from mope.client import Client, Mope, RequestTimeout - - -@pytest.mark.parametrize("timeout", [2, 2.5, (1, 3), (1.5, 3.5)]) -def test_configured_timeout_reaches_transport(timeout: RequestTimeout) -> None: - with patch("requests.request") as request: - client = Client("token", timeout=timeout) - client.call_api("GET", "shop/payment_request/payment-123") - assert request.call_args.kwargs["timeout"] == timeout - assert request.call_args.kwargs["url"] == ( - "https://api.mope.sr/api/shop/payment_request/payment-123" - ) - - api = Mope("token", timeout=timeout) - request.return_value.json.return_value = { - "id": "payment-123", - "url": "https://mope.sr/p/payment-123", - } - api.shop.create_payment_request( - 100, "order", "order-1", "SRD", "https://example.com" - ) - assert request.call_args.kwargs["timeout"] == timeout - - -@pytest.mark.parametrize( - "timeout", [0.0, -1.0, float("inf"), float("nan"), (1.0, 0.0), (float("inf"), 2.0)] -) -@pytest.mark.parametrize("client_type", [Client, Mope]) -def test_non_positive_or_unbounded_timeout_is_rejected( - client_type: type[Client] | type[Mope], timeout: RequestTimeout -) -> None: - with pytest.raises(ValueError, match="finite and greater than zero"): - client_type("token", timeout=timeout) - - -@pytest.mark.parametrize( - "failure", [Timeout("timeout"), ConnectionError("connection failed")] -) -def test_network_errors_propagate_without_retry(failure: Exception) -> None: - with patch("requests.request", side_effect=failure) as request: - with pytest.raises(type(failure)) as raised: - Mope("token").shop.create_payment_request( - 100, "order", "order-1", "SRD", "https://example.com" - ) - assert raised.value is failure - request.assert_called_once() - - -def test_read_timeout_interrupts_a_stalled_http_response() -> None: - received = Event() - release = Event() - - class StalledHandler(BaseHTTPRequestHandler): - def do_GET(self) -> None: - received.set() - release.wait(timeout=5) - - with ThreadingHTTPServer(("127.0.0.1", 0), StalledHandler) as server: - worker = Thread(target=server.serve_forever) - worker.start() - try: - with pytest.raises(ReadTimeout): - Client("token", timeout=(1.0, 0.1)).call_api( - "GET", f"http://127.0.0.1:{server.server_port}/stalled" - ) - assert received.is_set() - finally: - release.set() - server.shutdown() - worker.join(timeout=5) diff --git a/tests/test_errors.py b/tests/test_errors.py deleted file mode 100644 index d75b5e4..0000000 --- a/tests/test_errors.py +++ /dev/null @@ -1,131 +0,0 @@ -import json -import pickle -from unittest.mock import patch - -import pytest -from requests import HTTPError, Request, Response - -from mope.client import Mope -from mope.errors import MopeAPIError, raise_for_status -from mope.json import JsonObject - - -def error_response(body: bytes, status_code: int = 400) -> Response: - response = Response() - response.status_code = status_code - response.reason = "Bad Request" if status_code == 400 else "Service Unavailable" - response.url = "https://api.mope.sr/api/shop/payment_request" - response.request = Request("POST", response.url).prepare() - response._content = body - return response - - -@pytest.mark.parametrize("wrapped", [True, False]) -def test_api_error_exposes_validated_details_and_preserves_http_error( - wrapped: bool, -) -> None: - details: JsonObject = { - "code": 1033, - "message": "Account limits exceeded", - "data": {"limit": 100}, - } - payload: JsonObject = {"error": details} if wrapped else details - response = error_response(json.dumps(payload).encode()) - - with pytest.raises(HTTPError) as raised: - raise_for_status(response) - - error = raised.value - assert isinstance(error, MopeAPIError) - assert error.code == 1033 - assert error.message == "Account limits exceeded" - assert str(error) == "Account limits exceeded" - assert error.data == {"limit": 100} - assert error.status_code == 400 - assert error.response is response - assert error.request is response.request - assert isinstance(error.__cause__, HTTPError) - assert error.__cause__.response is response - - -@pytest.mark.parametrize( - "body", - [ - b"", - b"Service unavailable", - b"null", - b"[]", - b"{}", - b'{"error": null}', - b'{"error": {"code": "1033", "message": "Invalid code"}}', - b'{"error": {"code": true, "message": "Invalid code"}}', - b'{"error": {"code": 1033, "message": 42}}', - b'{"error": {"message": "Missing code"}}', - b'{"error": {"code": 1033}}', - b'{"error": {"code": 1033, "message": "Invalid data", "data": NaN}}', - ], -) -def test_bad_error_body_preserves_http_failure(body: bytes) -> None: - response = error_response(body, status_code=503) - - with pytest.raises(MopeAPIError) as raised: - raise_for_status(response) - - error = raised.value - assert error.status_code == 503 - assert error.code is None - assert error.data is None - assert "503" in error.message - assert "Service Unavailable" in error.message - assert error.response is response - assert isinstance(error.__cause__, HTTPError) - - -@pytest.mark.parametrize("create", [True, False]) -def test_shop_methods_raise_typed_api_errors(create: bool) -> None: - response = error_response( - b'{"error": {"code": 1033, "message": "Account limits exceeded"}}' - ) - with patch("requests.request", return_value=response): - with pytest.raises(MopeAPIError) as raised: - client = Mope("token") - if create: - client.shop.create_payment_request( - 100, "order", "order-1", "SRD", "https://example.com" - ) - else: - client.shop.get_payment_request("payment-123") - - assert raised.value.code == 1033 - - -@pytest.mark.parametrize( - "body, expected", - [ - (b"OK", ValueError), - (b"{}", KeyError), - (b'{"id": 1, "url": "https://mope.sr/p/1"}', TypeError), - ], -) -def test_invalid_success_response_keeps_validation_exceptions( - body: bytes, expected: type[Exception] -) -> None: - response = error_response(body, status_code=200) - with patch("requests.request", return_value=response): - with pytest.raises(expected): - Mope("token").shop.create_payment_request( - 100, "order", "order-1", "SRD", "https://example.com" - ) - - -def test_api_error_survives_serialization() -> None: - response = error_response( - b'{"error": {"code": 1033, "message": "Account limits exceeded", "data": null}}' - ) - error = MopeAPIError.from_response(response, fallback_message="HTTP error") - restored: object = pickle.loads(pickle.dumps(error)) - assert isinstance(restored, MopeAPIError) - assert restored.status_code == 400 - assert restored.code == 1033 - assert restored.message == "Account limits exceeded" - assert restored.data is None diff --git a/tests/test_models.py b/tests/test_models.py deleted file mode 100644 index a024df5..0000000 --- a/tests/test_models.py +++ /dev/null @@ -1,167 +0,0 @@ -import pytest - -from mope.json import JsonObject, json_object -from mope.models.payments import ( - BaseModel, - CreatePaymentResponse, - Currency, - PaymentRequest, - PaymentStatus, -) - - -@pytest.fixture -def payment_payload() -> JsonObject: - return { - "id": "payment-123", - "amount": 35638, - "created_at": "2019-12-02T14:28:14+00:00", - "description": "Order for a lot of beer", - "expires_at": "2019-12-03T14:28:14+00:00", - "currency": {"name": "Surinamese dollar", "code": "SRD", "symbol": "$"}, - "status": "paid", - "meta_data": [{"key": "order_id", "value": "beer-order-123"}], - } - - -@pytest.mark.parametrize("status", ["open", "scanned", "unconfirmed", "paid"]) -def test_payment_round_trip(payment_payload: JsonObject, status: PaymentStatus) -> None: - payment_payload["status"] = status - payment = PaymentRequest.from_json(payment_payload) - - assert payment.amount == 35638 - assert isinstance(payment.currency, Currency) - assert payment.currency.code == "SRD" - assert payment.status == status - assert payment.meta_data == [{"key": "order_id", "value": "beer-order-123"}] - assert payment.as_dict() == payment_payload - - -@pytest.mark.parametrize("amount", [True, False, "100", 100.5, None]) -def test_amount_is_not_coerced(payment_payload: JsonObject, amount: object) -> None: - payload: dict[str, object] = dict(payment_payload) - payload["amount"] = amount - - with pytest.raises(TypeError, match="amount must be an integer"): - PaymentRequest.from_json(payload) - - -@pytest.mark.parametrize("field", ["id", "created_at", "description", "expires_at"]) -def test_payment_string_fields_are_validated( - payment_payload: JsonObject, field: str -) -> None: - payment_payload[field] = 123 - - with pytest.raises(TypeError, match=f"{field} must be a string"): - PaymentRequest.from_json(payment_payload) - - -@pytest.mark.parametrize("status", ["expired", None, 1, True]) -def test_invalid_status_is_rejected( - payment_payload: JsonObject, status: object -) -> None: - payload: dict[str, object] = dict(payment_payload) - payload["status"] = status - - with pytest.raises(ValueError, match="status must be"): - PaymentRequest.from_json(payload) - - -@pytest.mark.parametrize( - "metadata", - [None, {}, "metadata", [1], [{"key": 1, "value": "x"}], [{"key": "x", "value": 1}]], -) -def test_metadata_is_validated(payment_payload: JsonObject, metadata: object) -> None: - payload: dict[str, object] = dict(payment_payload) - payload["meta_data"] = metadata - - with pytest.raises(TypeError, match="meta_data"): - PaymentRequest.from_json(payload) - - -@pytest.mark.parametrize("field", ["key", "value"]) -def test_metadata_requires_both_fields(payment_payload: JsonObject, field: str) -> None: - entry: JsonObject = {"key": "order_id", "value": "order-123"} - del entry[field] - payment_payload["meta_data"] = [entry] - - with pytest.raises(KeyError, match=field): - PaymentRequest.from_json(payment_payload) - - -@pytest.mark.parametrize( - "field", - [ - "id", - "amount", - "created_at", - "description", - "expires_at", - "currency", - "status", - "meta_data", - ], -) -def test_payment_requires_all_fields(payment_payload: JsonObject, field: str) -> None: - del payment_payload[field] - - with pytest.raises(KeyError, match=field): - PaymentRequest.from_json(payment_payload) - - -@pytest.mark.parametrize("field", ["name", "code", "symbol"]) -def test_currency_fields_are_validated(field: str) -> None: - payload: JsonObject = {"name": "Surinamese dollar", "code": "SRD", "symbol": "$"} - payload[field] = None - - with pytest.raises(TypeError, match=f"currency.{field} must be a string"): - Currency.from_json(payload) - - -@pytest.mark.parametrize("field", ["id", "url"]) -def test_creation_fields_are_validated(field: str) -> None: - payload: JsonObject = {"id": "payment-123", "url": "https://mope.sr/p/payment-123"} - payload[field] = 123 - - with pytest.raises(TypeError, match=f"{field} must be a string"): - CreatePaymentResponse.from_json(payload) - - -@pytest.mark.parametrize("model", [CreatePaymentResponse, Currency, PaymentRequest]) -@pytest.mark.parametrize("payload", [None, [], "response", 1]) -def test_models_require_objects(model: type[BaseModel], payload: object) -> None: - with pytest.raises(TypeError, match="must be a JSON object"): - model.from_json(payload) - - -@pytest.mark.parametrize("payload", [{1: "value"}, {"nested": {1: "value"}}]) -def test_json_object_keys_must_be_strings(payload: object) -> None: - with pytest.raises(TypeError, match="must have string keys"): - json_object(payload) - - -@pytest.mark.parametrize("value", [object(), {1, 2}, (1, 2)]) -def test_non_json_values_are_rejected(value: object) -> None: - with pytest.raises(TypeError, match="must be a JSON value"): - json_object({"nested": [value]}) - - -@pytest.mark.parametrize("value", [float("nan"), float("inf"), float("-inf")]) -def test_non_finite_json_numbers_are_rejected(value: float) -> None: - with pytest.raises(ValueError, match="finite JSON number"): - json_object({"nested": [value]}) - - -def test_json_preserves_valid_nested_values() -> None: - payload: JsonObject = {"nested": [None, True, 1, 1.5, "text", {"key": "value"}]} - assert json_object(payload) == payload - - -def test_serialization_does_not_share_mutable_metadata( - payment_payload: JsonObject, -) -> None: - payment = PaymentRequest.from_json(payment_payload) - serialized = payment.as_dict() - payment.meta_data[0]["value"] = "changed" - - assert serialized == payment_payload diff --git a/tests/test_mope.py b/tests/test_mope.py index 858e6b3..dc73b4a 100644 --- a/tests/test_mope.py +++ b/tests/test_mope.py @@ -1,135 +1,204 @@ -import unittest -from unittest import mock -from unittest.mock import Mock +import json +from collections.abc import Iterator +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from threading import Event, Thread +from unittest.mock import Mock, patch -from requests import HTTPError, Response +import pytest +from requests import HTTPError, ReadTimeout, Response, Timeout -from mope import Mope -from mope.__version__ import __version__ +from mope.client import Client, Mope, RequestTimeout +from mope.errors import MopeAPIError from mope.json import JsonObject -from mope.models.payments import CreatePaymentResponse, Currency, PaymentRequest - -mock_payment_request: JsonObject = { - "id": "c43f24a3-df4f-43b7-9045-b454529369dc", - "amount": 35638, - "created_at": "2019-12-02T14:28:14+00:00", - "description": "Order for a lot of beer", - "expires_at": "2019-12-03T14:28:14+00:00", - "currency": {"name": "Surinamese dollar", "code": "SRD", "symbol": "$"}, - "status": "paid", - "meta_data": [], -} - - -class MopeTestCase(unittest.TestCase): - def setUp(self) -> None: - self.mope = Mope("fake-token") - self.client = self.mope._client - - @mock.patch("requests.request") - def test_call_api(self, mock_request: Mock) -> None: - expected_response = Response() - mock_request.return_value = expected_response - response = self.client.call_api( - "POST", "shop/payment_request", json={"amount": 1000} - ) - self.assertIs(response, expected_response) - - mock_request.assert_called_once_with( - url="https://api.mope.sr/api/shop/payment_request", - json={"amount": 1000}, - data=None, - method="POST", - params=None, - timeout=(5.0, 30.0), - headers={ - "User-Agent": f"Python Mope {__version__}", - "Content-Type": "application/json", - "Authorization": "Bearer fake-token", - }, - ) - - @mock.patch("requests.request") - def test_shop_create_payment_request(self, mock_request: Mock) -> None: - payload = {"id": "payment-123", "url": "https://api.mope.sr/pay/payment-123"} - mock_request.return_value.json.return_value = payload - - response = self.mope.shop.create_payment_request( - amount=1000, - description="test", - order_id="test-1", - currency="SRD", - redirect_url="https://www.sup.com/products/1", - ) - self.assertIsInstance(response, CreatePaymentResponse) - self.assertEqual(response.as_dict(), payload) - mock_request.assert_called_once_with( - method="POST", - url="https://api.mope.sr/api/shop/payment_request", - params=None, - data=None, - timeout=(5.0, 30.0), - json={ - "amount": 1000, - "order_id": "test-1", - "currency": "SRD", - "description": "test", - "redirect_url": "https://www.sup.com/products/1", - }, - headers={ - "User-Agent": f"Python Mope {__version__}", - "Content-Type": "application/json", - "Authorization": "Bearer fake-token", - }, - ) - @mock.patch("requests.request") - def test_shop_get_payment_request(self, mock_request: Mock) -> None: - mock_request.return_value = Mock(ok=True) - mock_request.return_value.json.return_value = mock_payment_request - mock_response = self.mope.shop.get_payment_request( - payment_id="c43f24a3-df4f-43b7-9045-b454529369dc" - ) - - self.assertTrue(isinstance(mock_response, PaymentRequest)) - self.assertTrue(isinstance(mock_response.currency, Currency)) - - self.assertEqual(mock_response.as_dict(), mock_payment_request) - self.assertEqual( - mock_request.call_args.kwargs["url"], - "https://api.mope.sr/api/shop/payment_request/" - "c43f24a3-df4f-43b7-9045-b454529369dc", - ) - self.assertEqual(mock_request.call_args.kwargs["timeout"], (5.0, 30.0)) - - @mock.patch("requests.request") - def test_invalid_response_is_rejected(self, mock_request: Mock) -> None: - mock_request.return_value.json.return_value = { - **mock_payment_request, - "amount": True, - } - - with self.assertRaisesRegex(TypeError, "amount must be an integer"): - self.mope.shop.get_payment_request("payment-123") - - @mock.patch("requests.request") - def test_invalid_request_json_is_rejected(self, mock_request: Mock) -> None: - with self.assertRaisesRegex(TypeError, "request.amount must be a JSON value"): - self.client.call_api("POST", "endpoint", json={"amount": object()}) - - mock_request.assert_not_called() - - @mock.patch("requests.request") - def test_http_errors_are_raised_before_parsing(self, mock_request: Mock) -> None: - response = Response() - response.status_code = 404 - response._content = b'{"error": {"code": 1002, "message": "Not found"}}' - mock_request.return_value = response - - with self.assertRaises(HTTPError): - self.mope.shop.get_payment_request("payment-123") - with self.assertRaises(HTTPError): - self.mope.shop.create_payment_request( - 100, "order", "order-1", "SRD", "https://example.com" +@pytest.fixture +def payment() -> JsonObject: + return { + "id": "payment-123", + "amount": 35638, + "created_at": "2019-12-02T14:28:14+00:00", + "description": "Order", + "expires_at": "2019-12-03T14:28:14+00:00", + "currency": {"name": "Surinamese dollar", "code": "SRD", "symbol": "$"}, + "status": "paid", + "meta_data": [{"key": "order_id", "value": "order-1"}], + } + + +@pytest.fixture +def http_request() -> Iterator[Mock]: + with patch("requests.request") as request: + yield request + + +def response_for(payload: object, status: int = 200) -> Response: + response = Response() + response.status_code = status + response._content = json.dumps(payload).encode() + return response + + +def test_create_payment_sends_correct_request(http_request: Mock) -> None: + created = {"id": "payment-123", "url": "https://mope.sr/p/payment-123"} + http_request.return_value = response_for(created) + result = Mope("token").shop.create_payment_request( + 100, "Order", "order-1", "SRD", "https://example.com/return" + ) + + assert result.as_dict() == created + http_request.assert_called_once() + sent = http_request.call_args.kwargs + assert sent["method"] == "POST" + assert sent["url"] == "https://api.mope.sr/api/shop/payment_request" + assert sent["headers"]["Authorization"] == "Bearer token" + assert sent["timeout"] == (5.0, 30.0) + assert sent["json"] == { + "amount": 100, + "description": "Order", + "order_id": "order-1", + "currency": "SRD", + "redirect_url": "https://example.com/return", + } + + +@pytest.mark.parametrize("timeout", [2.5, (1.0, 3.0)]) +def test_fetch_payment_preserves_details_and_configured_timeout( + http_request: Mock, payment: JsonObject, timeout: RequestTimeout +) -> None: + http_request.return_value = response_for(payment) + result = Mope("token", timeout=timeout).shop.get_payment_request("payment-123") + + assert result.as_dict() == payment + assert result.currency.code == "SRD" + http_request.assert_called_once() + sent = http_request.call_args.kwargs + assert sent["method"] == "GET" + assert sent["url"] == "https://api.mope.sr/api/shop/payment_request/payment-123" + assert sent["timeout"] == timeout + + +@pytest.mark.parametrize("create", [True, False]) +def test_shop_errors_preserve_api_details_and_http_error_compatibility( + http_request: Mock, create: bool +) -> None: + code = 1033 if create else 1002 + details: JsonObject = { + "code": code, + "message": "API rejected request", + "data": {"reason": "test"}, + } + # Exercise both shapes shown in Mopé's schema and examples. + response = response_for({"error": details} if create else details, status=400) + http_request.return_value = response + client = Mope("token") + + with pytest.raises(HTTPError) as raised: + if create: + client.shop.create_payment_request( + 100, "Order", "order-1", "SRD", "https://example.com" ) + else: + client.shop.get_payment_request("payment-123") + + error = raised.value + assert isinstance(error, MopeAPIError) + assert error.status_code == 400 + assert error.code == code + assert error.message == details["message"] + assert error.data == details["data"] + assert error.response is response + assert isinstance(error.__cause__, HTTPError) + + +@pytest.mark.parametrize( + "body", + [ + b"Service unavailable", + b'{"error": {"code": "invalid", "message": "Error"}}', + ], +) +def test_malformed_error_body_does_not_mask_http_failure( + http_request: Mock, body: bytes +) -> None: + response = response_for(None, status=503) + response._content = body + http_request.return_value = response + + with pytest.raises(MopeAPIError) as raised: + Mope("token").shop.get_payment_request("payment-123") + + assert raised.value.status_code == 503 + assert raised.value.code is None + assert "503" in raised.value.message + assert raised.value.response is response + + +@pytest.mark.parametrize( + "invalid, expected", + [ + ("json", ValueError), + ("missing", KeyError), + ("amount", TypeError), + ("status", ValueError), + ("meta_data", TypeError), + ], +) +def test_invalid_payment_response_is_rejected( + http_request: Mock, payment: JsonObject, invalid: str, expected: type[Exception] +) -> None: + changes: JsonObject = { + "amount": True, + "status": "unknown", + "meta_data": [{"key": "order_id", "value": 1}], + } + if invalid in changes: + payment[invalid] = changes[invalid] + response = response_for({} if invalid == "missing" else payment) + if invalid == "json": + response._content = b"not JSON" + http_request.return_value = response + + with pytest.raises(expected): + Mope("token").shop.get_payment_request("payment-123") + + +@pytest.mark.parametrize("timeout", [0.0, (1.0, float("inf"))]) +def test_timeout_must_be_positive_and_finite(timeout: RequestTimeout) -> None: + with pytest.raises(ValueError, match="finite and greater than zero"): + Mope("token", timeout=timeout) + + +def test_payment_creation_timeout_is_not_retried(http_request: Mock) -> None: + failure = Timeout("Server stopped responding") + http_request.side_effect = failure + with pytest.raises(Timeout) as raised: + Mope("token").shop.create_payment_request( + 100, "Order", "order-1", "SRD", "https://example.com" + ) + assert raised.value is failure + http_request.assert_called_once() + + +def test_read_timeout_interrupts_a_stalled_http_response() -> None: + received = Event() + release = Event() + + class StalledHandler(BaseHTTPRequestHandler): + def do_GET(self) -> None: + received.set() + release.wait(timeout=5) + + with ThreadingHTTPServer(("127.0.0.1", 0), StalledHandler) as server: + worker = Thread(target=server.serve_forever) + worker.start() + try: + with pytest.raises(ReadTimeout): + Client("token", timeout=(1.0, 0.1)).call_api( + "GET", f"http://127.0.0.1:{server.server_port}/stalled" + ) + assert received.is_set() + finally: + release.set() + server.shutdown() + worker.join(timeout=5) diff --git a/tests/typing.py b/tests/typing.py index ed0c0a2..b5421df 100644 --- a/tests/typing.py +++ b/tests/typing.py @@ -1,79 +1,38 @@ -"""Static contract checks, analyzed by ty without making network calls.""" +"""Verify that installed-package consumers retain useful types.""" from typing import assert_type -from requests import HTTPError, Response +from requests import Response -from mope import Mope -from mope.client import Client +from mope.client import Client, Mope from mope.errors import MopeAPIError from mope.json import JsonObject, JsonValue -from mope.models.payments import ( - CreatePaymentResponse, - Currency, - PaymentMetadata, - PaymentRequest, - PaymentStatus, -) -from mope.resources.shop import ShopResource -from mope.transport import ApiTransport +from mope.models.payments import CreatePaymentResponse, PaymentRequest, PaymentStatus -class CustomPaymentRequest(PaymentRequest): - pass - - -def check_public_types(client: Mope, transport: Client, payload: object) -> None: - api_transport: ApiTransport = transport - assert_type( - api_transport.call_api("GET", "shop/payment_request/payment-1"), Response - ) - assert_type(client.shop, ShopResource) +def check_payment_types(client: Mope) -> None: created = client.shop.create_payment_request( - 100, "order", "order-1", "EUR", "https://example.com" + 100, "Order", "order-1", "SRD", "https://example.com" ) assert_type(created, CreatePaymentResponse) - assert_type(created.id, str) - assert_type(created.url, str) - payment = client.shop.get_payment_request("payment-1") + payment = client.shop.get_payment_request("payment-123") assert_type(payment, PaymentRequest) assert_type(payment.amount, int) - assert_type(payment.currency, Currency) assert_type(payment.status, PaymentStatus) - assert_type(payment.meta_data, list[PaymentMetadata]) assert_type(payment.meta_data[0]["value"], str) assert_type(payment.as_dict(), JsonObject) - assert_type(transport.call_api("GET", "shop/payment_request/payment-1"), Response) - assert_type(CreatePaymentResponse.from_json(payload), CreatePaymentResponse) - assert_type(Currency.from_json(payload), Currency) - assert_type(PaymentRequest.from_json(payload), PaymentRequest) - assert_type(CustomPaymentRequest.from_json(payload), CustomPaymentRequest) -def check_transport_inputs( - transport: Client, - query: dict[str, str], - form: dict[str, str], - payload: dict[str, int], +def check_inputs_and_errors( + params: dict[str, str], payload: dict[str, int], error: MopeAPIError ) -> None: + client = Client("token", timeout=5.0) + Mope("token", timeout=(1.0, 5.0)) assert_type( - transport.call_api("POST", "endpoint", params=query, data=form, json=payload), + client.call_api("POST", "endpoint", params=params, data=params, json=payload), Response, ) - - -def check_timeout_and_error_types(error: MopeAPIError, response: Response) -> None: - assert_type(Mope("token", timeout=10.0), Mope) - assert_type(Mope("token", timeout=(3.0, 15.0)), Mope) - assert_type(Client("token", timeout=10), Client) - assert_type(Client("token", timeout=(3, 15)), Client) - http_error: HTTPError = error - assert_type(http_error, MopeAPIError) - assert_type(error.status_code, int | None) assert_type(error.code, int | None) + assert_type(error.status_code, int | None) assert_type(error.message, str) assert_type(error.data, JsonValue) - assert_type( - MopeAPIError.from_response(response, fallback_message="HTTP error"), - MopeAPIError, - )