instantpay-sa 0.1.0__tar.gz

instantpay_sa-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+node_modules/
+dist/
+.next/
+.turbo/
+coverage/
+*.tsbuildinfo
+.env
+.env.*.local
+!.env.example
+next-env.d.ts
+playwright-report/
+test-results/
+.DS_Store
+e2e/test-results/
+e2e/playwright-report/

instantpay_sa-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 InstantPay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

instantpay_sa-0.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.5
+Name: instantpay-sa
+Version: 0.1.0
+Summary: Official Python library for the InstantPay API (Saudi merchant payments).
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# instantpay (Python)
+
+Official Python library for the [InstantPay](https://developers.instantpay.sa) API. Python 3.9+,
+standard library only.
+
+```bash
+pip install instantpay-sa   # the package is instantpay-sa; you import instantpay
+```
+
+```python
+import instantpay
+
+ip = instantpay.InstantPay(os.environ["INSTANTPAY_API_KEY"],
+                           base_url="https://instantpay-api.onrender.com")  # demo sandbox
+
+checkout = ip.payment_intents.create(amount="250.00", description="Order 1001",
+                                     reference="1001", return_url="https://shop.example.sa/orders/1001")
+# redirect the customer to checkout["checkout_url"]
+
+for payment in ip.payments.all(state="settled"):   # every page
+    print(payment["id"], payment["amount"]["amount"])
+
+ip.refunds.create(payment_id="pay_…", amount="20.00", reason="One item returned")
+
+# Webhooks (Flask): the raw body, then the event
+event = instantpay.webhooks.construct_event(request.get_data(),
+                                            request.headers.get("InstantPay-Signature"),
+                                            os.environ["INSTANTPAY_WEBHOOK_SECRET"])
+```
+
+Errors are `instantpay.InstantPayError` with `status`, `code`, `param` and `request_id`.
+Options: `base_url`, `timeout` (30), `max_retries` (2), `transport`. Tests:
+`python3 -m unittest discover -s tests`.

instantpay_sa-0.1.0/README.md

@@ -0,0 +1,33 @@
+# instantpay (Python)
+
+Official Python library for the [InstantPay](https://developers.instantpay.sa) API. Python 3.9+,
+standard library only.
+
+```bash
+pip install instantpay-sa   # the package is instantpay-sa; you import instantpay
+```
+
+```python
+import instantpay
+
+ip = instantpay.InstantPay(os.environ["INSTANTPAY_API_KEY"],
+                           base_url="https://instantpay-api.onrender.com")  # demo sandbox
+
+checkout = ip.payment_intents.create(amount="250.00", description="Order 1001",
+                                     reference="1001", return_url="https://shop.example.sa/orders/1001")
+# redirect the customer to checkout["checkout_url"]
+
+for payment in ip.payments.all(state="settled"):   # every page
+    print(payment["id"], payment["amount"]["amount"])
+
+ip.refunds.create(payment_id="pay_…", amount="20.00", reason="One item returned")
+
+# Webhooks (Flask): the raw body, then the event
+event = instantpay.webhooks.construct_event(request.get_data(),
+                                            request.headers.get("InstantPay-Signature"),
+                                            os.environ["INSTANTPAY_WEBHOOK_SECRET"])
+```
+
+Errors are `instantpay.InstantPayError` with `status`, `code`, `param` and `request_id`.
+Options: `base_url`, `timeout` (30), `max_retries` (2), `transport`. Tests:
+`python3 -m unittest discover -s tests`.

instantpay_sa-0.1.0/instantpay/__init__.py

@@ -0,0 +1,15 @@
+"""Official Python library for the InstantPay API.
+
+    import instantpay
+    ip = instantpay.InstantPay("ipk_test_...", base_url="https://instantpay-api.onrender.com")
+    checkout = ip.payment_intents.create(amount="250.00", description="Order 1001")
+
+Standard library only (urllib, hmac, json).
+"""
+
+from .client import DEFAULT_BASE_URL, VERSION, InstantPay
+from .errors import InstantPayError
+from . import webhooks
+
+__all__ = ["InstantPay", "InstantPayError", "webhooks", "DEFAULT_BASE_URL", "VERSION"]
+__version__ = VERSION

instantpay_sa-0.1.0/instantpay/client.py

@@ -0,0 +1,240 @@
+import json
+import random
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Callable, Dict, Iterator, Optional
+
+from . import webhooks as _webhooks
+from .errors import InstantPayError
+
+VERSION = "0.1.0"
+#: Production API. For the public demo use https://instantpay-api.onrender.com.
+DEFAULT_BASE_URL = "https://api.instantpay.sa"
+
+JSON = Dict[str, Any]
+# (method, url, headers, body, timeout) -> (status, headers, body)
+Transport = Callable[[str, str, Dict[str, str], Optional[bytes], float], "tuple[int, Dict[str, str], bytes]"]
+
+
+def _urllib_transport(method, url, headers, body, timeout):
+    req = urllib.request.Request(url, data=body, method=method, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as res:  # noqa: S310 (https by default)
+            return res.status, {k.lower(): v for k, v in res.headers.items()}, res.read()
+    except urllib.error.HTTPError as e:
+        return e.code, {k.lower(): v for k, v in e.headers.items()}, e.read()
+
+
+class _Resource:
+    def __init__(self, client: "InstantPay") -> None:
+        self._c = client
+
+
+class PaymentIntents(_Resource):
+    """Online checkout: send the customer to ``checkout_url``; confirm with the webhook or retrieve()."""
+
+    def create(self, idempotency_key: Optional[str] = None, **params: Any) -> JSON:
+        return self._c.request("POST", "/v1/payment_intents", body=params, idempotency_key=idempotency_key)
+
+    def retrieve(self, intent_id: str) -> JSON:
+        return self._c.request("GET", f"/v1/payment_intents/{_q(intent_id)}")
+
+    def list(self, **params: Any) -> JSON:
+        return self._c.request("GET", "/v1/payment_intents", query=params)
+
+    def all(self, **params: Any) -> Iterator[JSON]:
+        return self._c.paginate("/v1/payment_intents", params)
+
+
+class PaymentLinks(_Resource):
+    def create(self, idempotency_key: Optional[str] = None, **params: Any) -> JSON:
+        params.setdefault("currency", "SAR")
+        params.setdefault("expires_in_days", 7)
+        return self._c.request("POST", "/v1/payment_links", body=params, idempotency_key=idempotency_key)
+
+    def retrieve(self, link_id: str) -> JSON:
+        return self._c.request("GET", f"/v1/payment_links/{_q(link_id)}")
+
+    def list(self, **params: Any) -> JSON:
+        return self._c.request("GET", "/v1/payment_links", query=params)
+
+    def all(self, **params: Any) -> Iterator[JSON]:
+        return self._c.paginate("/v1/payment_links", params)
+
+    def cancel(self, link_id: str) -> JSON:
+        return self._c.request("POST", f"/v1/payment_links/{_q(link_id)}/cancel")
+
+
+class Payments(_Resource):
+    def retrieve(self, payment_id: str) -> JSON:
+        return self._c.request("GET", f"/v1/payments/{_q(payment_id)}")
+
+    def list(self, **params: Any) -> JSON:
+        """Filters: channel, state (approved|settled), q (order number, RRN, last 4)."""
+        return self._c.request("GET", "/v1/payments", query=params)
+
+    def all(self, **params: Any) -> Iterator[JSON]:
+        return self._c.paginate("/v1/payments", params)
+
+
+class Refunds(_Resource):
+    def create(self, idempotency_key: Optional[str] = None, **params: Any) -> JSON:
+        """Full or partial; the amount leaves your wallet at once."""
+        return self._c.request("POST", "/v1/refunds", body=params, idempotency_key=idempotency_key)
+
+
+class Payouts(_Resource):
+    def create(self, idempotency_key: Optional[str] = None, **params: Any) -> JSON:
+        params.setdefault("currency", "SAR")
+        return self._c.request("POST", "/v1/payouts", body=params, idempotency_key=idempotency_key)
+
+    def retrieve(self, payout_id: str) -> JSON:
+        return self._c.request("GET", f"/v1/payouts/{_q(payout_id)}")
+
+    def list(self, **params: Any) -> JSON:
+        return self._c.request("GET", "/v1/payouts", query=params)
+
+    def all(self, **params: Any) -> Iterator[JSON]:
+        return self._c.paginate("/v1/payouts", params)
+
+
+class Beneficiaries(_Resource):
+    def list(self) -> JSON:
+        return self._c.request("GET", "/v1/beneficiaries")
+
+
+class Wallets(_Resource):
+    def list(self) -> JSON:
+        return self._c.request("GET", "/v1/wallets")
+
+    def retrieve(self, wallet_id: str) -> JSON:
+        return self._c.request("GET", f"/v1/wallets/{_q(wallet_id)}")
+
+    def transactions(self, wallet_id: str, **params: Any) -> JSON:
+        return self._c.request("GET", f"/v1/wallets/{_q(wallet_id)}/transactions", query=params)
+
+
+class WebhookEndpoints(_Resource):
+    def create(self, **params: Any) -> JSON:
+        """The response carries the signing ``secret`` once; store it."""
+        return self._c.request("POST", "/v1/webhook_endpoints", body=params)
+
+    def list(self) -> JSON:
+        return self._c.request("GET", "/v1/webhook_endpoints")
+
+    def retrieve(self, endpoint_id: str) -> JSON:
+        return self._c.request("GET", f"/v1/webhook_endpoints/{_q(endpoint_id)}")
+
+    def delete(self, endpoint_id: str) -> None:
+        self._c.request("DELETE", f"/v1/webhook_endpoints/{_q(endpoint_id)}")
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class InstantPay:
+    """Client for one API key. Thread-safe: it keeps no per-request state."""
+
+    webhooks = _webhooks
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        transport: Optional[Transport] = None,
+    ) -> None:
+        if not re.match(r"^ipk_(test|live)_[0-9A-Za-z]{16,}$", api_key or ""):
+            raise ValueError("InstantPay: pass an API key like ipk_test_... (Portal > Developers).")
+        self._key = api_key
+        self._base = base_url.rstrip("/")
+        self._timeout = timeout
+        self._retries = max_retries
+        self._transport = transport or _urllib_transport
+        self.payment_intents = PaymentIntents(self)
+        self.payment_links = PaymentLinks(self)
+        self.payments = Payments(self)
+        self.refunds = Refunds(self)
+        self.payouts = Payouts(self)
+        self.beneficiaries = Beneficiaries(self)
+        self.wallets = Wallets(self)
+        self.webhook_endpoints = WebhookEndpoints(self)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        body: Optional[JSON] = None,
+        query: Optional[Dict[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        url = self._base + path
+        clean = {k: _param(v) for k, v in (query or {}).items() if v is not None and v != ""}
+        if clean:
+            url += "?" + urllib.parse.urlencode(clean)
+        headers = {
+            "Authorization": f"Bearer {self._key}",
+            "Accept": "application/json",
+            "User-Agent": f"instantpay-python/{VERSION}",
+        }
+        data = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode()
+        if method != "GET":
+            # Retries of a write reuse the key, so the API does it once.
+            headers["Idempotency-Key"] = idempotency_key or str(uuid.uuid4())
+
+        attempt = 0
+        while True:
+            try:
+                status, res_headers, raw = self._transport(method, url, headers, data, self._timeout)
+            except (urllib.error.URLError, OSError) as e:
+                if attempt < self._retries:
+                    time.sleep(_backoff(attempt))
+                    attempt += 1
+                    continue
+                raise InstantPayError(f"Could not reach InstantPay: {e}", 0, "network_error") from e
+            if (status == 429 or status >= 500) and attempt < self._retries:
+                after = res_headers.get("retry-after", "")
+                time.sleep(min(float(after), 20.0) if after.isdigit() else _backoff(attempt))
+                attempt += 1
+                continue
+            if status == 204 or not raw:
+                return None
+            payload = json.loads(raw.decode("utf-8"))
+            if status >= 400:
+                err = payload.get("error", {}) if isinstance(payload, dict) else {}
+                raise InstantPayError(
+                    err.get("message", f"HTTP {status}"),
+                    status,
+                    err.get("code", "http_error"),
+                    err.get("param"),
+                    res_headers.get("x-request-id"),
+                )
+            return payload
+
+    def paginate(self, path: str, params: Dict[str, Any]) -> Iterator[JSON]:
+        """Yields every item across pages: ``for p in ip.payments.all(state="settled"): ...``"""
+        query = dict(params)
+        while True:
+            page = self.request("GET", path, query=query)
+            for item in page.get("data", []):
+                yield item
+            if not page.get("has_more") or not page.get("next_cursor"):
+                return
+            query["starting_after"] = page["next_cursor"]
+
+
+def _param(v: Any) -> str:
+    return ("true" if v else "false") if isinstance(v, bool) else str(v)
+
+
+def _backoff(attempt: int) -> float:
+    return min(8.0, 0.5 * 2**attempt) + random.random() * 0.25

instantpay_sa-0.1.0/instantpay/errors.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+
+class InstantPayError(Exception):
+    """Every API failure. ``code`` is stable (e.g. ``insufficient_funds``); ``message`` is for people."""
+
+    def __init__(
+        self,
+        message: str,
+        status: int,
+        code: str,
+        param: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.param = param
+        self.request_id = request_id
+
+    def __repr__(self) -> str:
+        return f"InstantPayError(status={self.status}, code={self.code!r}, message={self.message!r})"

instantpay_sa-0.1.0/instantpay/webhooks.py

@@ -0,0 +1,61 @@
+"""Webhook signatures: ``InstantPay-Signature: t=<unix seconds>,v1=<hex HMAC-SHA256 of "t.body">``."""
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Dict, Optional, Union
+
+from .errors import InstantPayError
+
+SIGNATURE_TOLERANCE_SECONDS = 300
+
+Payload = Union[str, bytes]
+
+
+def _text(payload: Payload) -> str:
+    return payload.decode("utf-8") if isinstance(payload, bytes) else payload
+
+
+def sign(payload: Payload, secret: str, timestamp: Optional[int] = None) -> str:
+    t = int(time.time()) if timestamp is None else timestamp
+    v1 = hmac.new(secret.encode(), f"{t}.{_text(payload)}".encode(), hashlib.sha256).hexdigest()
+    return f"t={t},v1={v1}"
+
+
+def verify(
+    payload: Payload,
+    header: Optional[str],
+    secret: str,
+    tolerance_seconds: int = SIGNATURE_TOLERANCE_SECONDS,
+    now: Optional[float] = None,
+) -> bool:
+    """True when the signature is ours and fresh. Pass the raw request body."""
+    if not header:
+        return False
+    parts: Dict[str, str] = {}
+    for piece in header.split(","):
+        key, _, value = piece.partition("=")
+        parts[key.strip()] = value.strip()
+    try:
+        t = int(parts.get("t", ""))
+    except ValueError:
+        return False
+    current = time.time() if now is None else now
+    if abs(current - t) > tolerance_seconds:
+        return False
+    expected = sign(payload, secret, t).split("v1=", 1)[1]
+    return hmac.compare_digest(expected, parts.get("v1", ""))
+
+
+def construct_event(
+    payload: Payload,
+    header: Optional[str],
+    secret: str,
+    tolerance_seconds: int = SIGNATURE_TOLERANCE_SECONDS,
+    now: Optional[float] = None,
+) -> Dict[str, Any]:
+    """Verifies, then parses. Raises InstantPayError('invalid_signature') when it does not match."""
+    if not verify(payload, header, secret, tolerance_seconds, now):
+        raise InstantPayError("Webhook signature is not valid.", 400, "invalid_signature")
+    return json.loads(_text(payload))

instantpay_sa-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "instantpay-sa"
+version = "0.1.0"
+description = "Official Python library for the InstantPay API (Saudi merchant payments)."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+dependencies = []
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["instantpay"]

instantpay_sa-0.1.0/tests/test_client.py

@@ -0,0 +1,109 @@
+import json
+import os
+import time
+import unittest
+
+import instantpay
+from instantpay import InstantPay, InstantPayError, webhooks
+
+KEY = "ipk_test_abcdefghijklmnopqrstuvwxyz012345"
+
+
+class FakeTransport:
+    def __init__(self, responses):
+        self.responses = list(responses)
+        self.calls = []
+
+    def __call__(self, method, url, headers, body, timeout):
+        self.calls.append((method, url, dict(headers), body))
+        nxt = self.responses.pop(0)
+        if isinstance(nxt, Exception):
+            raise nxt
+        status, payload, extra = nxt if len(nxt) == 3 else (*nxt, {})
+        return status, extra, json.dumps(payload).encode() if payload is not None else b""
+
+
+class ClientTest(unittest.TestCase):
+    def test_refuses_non_keys(self):
+        with self.assertRaises(ValueError):
+            InstantPay("sk_live_x")
+
+    def test_retries_write_with_same_key(self):
+        t = FakeTransport([(503, {"error": {"code": "x", "message": "later"}}, {"retry-after": "0"}),
+                           (201, {"id": "pi_1"})])
+        ip = InstantPay(KEY, base_url="https://api.test/", transport=t)
+        pi = ip.payment_intents.create(amount="10.00", description="Order 1")
+        self.assertEqual(pi["id"], "pi_1")
+        self.assertEqual(len(t.calls), 2)
+        (m1, u1, h1, b1), (_, _, h2, _) = t.calls
+        self.assertEqual((m1, u1), ("POST", "https://api.test/v1/payment_intents"))
+        self.assertEqual(h1["Authorization"], f"Bearer {KEY}")
+        self.assertEqual(h1["Idempotency-Key"], h2["Idempotency-Key"])
+        self.assertEqual(json.loads(b1), {"amount": "10.00", "description": "Order 1"})
+
+    def test_errors(self):
+        t = FakeTransport([(422, {"error": {"code": "insufficient_funds", "message": "No.", "param": "amount"}},
+                            {"x-request-id": "req_1"})])
+        ip = InstantPay(KEY, base_url="https://api.test", transport=t)
+        with self.assertRaises(InstantPayError) as cm:
+            ip.refunds.create(payment_id="pay_1", amount="5.00", reason="x")
+        e = cm.exception
+        self.assertEqual((e.status, e.code, e.param, e.request_id), (422, "insufficient_funds", "amount", "req_1"))
+
+    def test_network_errors_give_up(self):
+        t = FakeTransport([OSError("down"), OSError("down")])
+        ip = InstantPay(KEY, base_url="https://api.test", transport=t, max_retries=1)
+        with self.assertRaises(InstantPayError) as cm:
+            ip.payments.retrieve("pay_1")
+        self.assertEqual(cm.exception.code, "network_error")
+
+    def test_pagination(self):
+        t = FakeTransport([(200, {"data": [{"id": "a"}, {"id": "b"}], "has_more": True, "next_cursor": "b"}),
+                           (200, {"data": [{"id": "c"}], "has_more": False, "next_cursor": None})])
+        ip = InstantPay(KEY, base_url="https://api.test", transport=t)
+        self.assertEqual([p["id"] for p in ip.payments.all(limit=2, pos=True)], ["a", "b", "c"])
+        self.assertIn("starting_after=b", t.calls[1][1])
+        self.assertIn("pos=true", t.calls[0][1])
+
+
+class WebhookTest(unittest.TestCase):
+    secret = "whsec_test123"
+    body = json.dumps({"id": "evt_1", "object": "event", "type": "payment.succeeded", "data": {}})
+
+    def test_verify(self):
+        header = webhooks.sign(self.body, self.secret, 1_000_000)
+        self.assertTrue(webhooks.verify(self.body, header, self.secret, now=1_000_010))
+        self.assertTrue(webhooks.verify(self.body.encode(), header, self.secret, now=1_000_010))
+        self.assertFalse(webhooks.verify(self.body + " ", header, self.secret, now=1_000_010))
+        self.assertFalse(webhooks.verify(self.body, header, "whsec_other", now=1_000_010))
+        self.assertFalse(webhooks.verify(self.body, header, self.secret, now=1_000_400))
+        self.assertFalse(webhooks.verify(self.body, None, self.secret))
+        self.assertEqual(webhooks.construct_event(self.body, header, self.secret, now=1_000_000)["type"],
+                         "payment.succeeded")
+        with self.assertRaises(InstantPayError):
+            webhooks.construct_event(self.body, "t=1,v1=00", self.secret)
+
+    def test_matches_node_signature(self):
+        # Same vector as the API's own signer: HMAC-SHA256 over "t.body".
+        self.assertEqual(webhooks.sign("{}", "whsec_x", 1700000000),
+                         "t=1700000000,v1=" + __import__("hmac").new(b"whsec_x", b"1700000000.{}", "sha256").hexdigest())
+
+
+@unittest.skipUnless(os.environ.get("INSTANTPAY_API_KEY"), "set INSTANTPAY_API_KEY for the live sandbox")
+class LiveTest(unittest.TestCase):
+    def test_checkout_and_link(self):
+        ip = InstantPay(os.environ["INSTANTPAY_API_KEY"],
+                        base_url=os.environ.get("INSTANTPAY_API_URL", "http://localhost:4000"))
+        pi = ip.payment_intents.create(amount="12.34", description="Python SDK order",
+                                       reference=f"py-{int(time.time())}", return_url="https://shop.example.sa/thanks")
+        self.assertRegex(pi["checkout_url"], r"/pay/[a-z0-9]{10}$")
+        self.assertEqual(ip.payment_intents.retrieve(pi["id"])["status"], "requires_payment")
+        link = ip.payment_links.create(amount="5.00", description="Python link")
+        self.assertEqual(ip.payment_links.cancel(link["id"])["status"], "cancelled")
+        with self.assertRaises(InstantPayError) as cm:
+            ip.payments.retrieve("pay_00000000000000000000000000")
+        self.assertEqual(cm.exception.status, 404)
+
+
+if __name__ == "__main__":
+    unittest.main()