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_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 3d48050..dc73b4a 100644 --- a/tests/test_mope.py +++ b/tests/test_mope.py @@ -1,126 +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", "https://api.mope.sr/api", json={"amount": 1000} - ) - self.assertIs(response, expected_response) - - mock_request.assert_called_once_with( - url="https://api.mope.sr/api", - json={"amount": 1000}, - data=None, - method="POST", - params=None, - 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/shop/payment_request", - params=None, - data=None, - 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) - - @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: - mock_request.return_value.raise_for_status.side_effect = HTTPError("Not found") - - 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" ) - - mock_request.return_value.json.assert_not_called() + 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 6a2a724..b5421df 100644 --- a/tests/typing.py +++ b/tests/typing.py @@ -1,61 +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 Response -from mope import Mope -from mope.client import Client -from mope.json import JsonObject -from mope.models.payments import ( - CreatePaymentResponse, - Currency, - PaymentMetadata, - PaymentRequest, - PaymentStatus, -) -from mope.resources.shop import ShopResource -from mope.transport import ApiTransport +from mope.client import Client, Mope +from mope.errors import MopeAPIError +from mope.json import JsonObject, JsonValue +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, ) + assert_type(error.code, int | None) + assert_type(error.status_code, int | None) + assert_type(error.message, str) + assert_type(error.data, JsonValue)