python-mope 0.3.0__tar.gz → 0.3.1__tar.gz

{python_mope-0.3.0 → python_mope-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-mope
-Version: 0.3.0
+Version: 0.3.1
 Summary: A client library for interacting with the Mopé Web Shop API
 Author-email: Lemuel Boyce <lemuel@vokality.com>
 License-Expression: MIT
@@ -52,6 +52,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:

{python_mope-0.3.0 → python_mope-0.3.1}/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:

{python_mope-0.3.0 → python_mope-0.3.1}/mope/__version__.py

@@ -1,2 +1,2 @@
 __author__ = "lemuel@vokality.com"
-__version__ = "0.3.0"
+__version__ = "0.3.1"

{python_mope-0.3.0 → python_mope-0.3.1}/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 @@ RequestData: TypeAlias = (
     | 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 @@ class Client:
             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)
 

python_mope-0.3.1/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

{python_mope-0.3.0 → python_mope-0.3.1}/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 @@ class ShopResource:
                 "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 @@ class ShopResource:
 
         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())

{python_mope-0.3.0 → python_mope-0.3.1}/python_mope.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-mope
-Version: 0.3.0
+Version: 0.3.1
 Summary: A client library for interacting with the Mopé Web Shop API
 Author-email: Lemuel Boyce <lemuel@vokality.com>
 License-Expression: MIT
@@ -52,6 +52,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:

{python_mope-0.3.0 → python_mope-0.3.1}/python_mope.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 mope/__init__.py
 mope/__version__.py
 mope/client.py
+mope/errors.py
 mope/json.py
 mope/py.typed
 mope/transport.py
@@ -16,5 +17,4 @@ python_mope.egg-info/SOURCES.txt
 python_mope.egg-info/dependency_links.txt
 python_mope.egg-info/requires.txt
 python_mope.egg-info/top_level.txt
-tests/test_models.py
 tests/test_mope.py

python_mope-0.3.1/tests/test_mope.py

@@ -0,0 +1,204 @@
+import json
+from collections.abc import Iterator
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from threading import Event, Thread
+from unittest.mock import Mock, patch
+
+import pytest
+from requests import HTTPError, ReadTimeout, Response, Timeout
+
+from mope.client import Client, Mope, RequestTimeout
+from mope.errors import MopeAPIError
+from mope.json import JsonObject
+
+
+@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"<html>Service unavailable</html>",
+        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)

python_mope-0.3.0/tests/test_models.py

@@ -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

python_mope-0.3.0/tests/test_mope.py

@@ -1,126 +0,0 @@
-import unittest
-from unittest import mock
-from unittest.mock import Mock
-
-from requests import HTTPError, Response
-
-from mope import Mope
-from mope.__version__ import __version__
-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"
-            )
-
-        mock_request.return_value.json.assert_not_called()