python-getpaid-paynow 3.0.0a3__tar.gz → 3.0.0a4__tar.gz

python_getpaid_paynow-3.0.0a4/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.12
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

{python_getpaid_paynow-3.0.0a3 → python_getpaid_paynow-3.0.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-getpaid-paynow
-Version: 3.0.0a3
+Version: 3.0.0a4
 Summary: Paynow payment gateway integration for python-getpaid ecosystem.
 Project-URL: Homepage, https://github.com/django-getpaid/python-getpaid-paynow
 Project-URL: Repository, https://github.com/django-getpaid/python-getpaid-paynow
@@ -19,6 +19,9 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: python-getpaid-core>=3.0.0a3
+Provides-Extra: simulator
+Requires-Dist: litestar>=2.0; extra == 'simulator'
+Requires-Dist: python-getpaid-simulator>=3.0.0a3; extra == 'simulator'
 Description-Content-Type: text/markdown
 
 # python-getpaid-paynow
@@ -64,6 +67,42 @@ Install the package using pip:
 pip install python-getpaid-paynow
 ```
 
+Install simulator support only when you want this package to register its local
+simulator plugin with `python-getpaid-simulator`:
+
+```bash
+pip install python-getpaid-paynow[simulator]
+```
+
+This extra installs the simulator host and Litestar dependencies, then exposes
+the `paynow` plugin through the `getpaid.simulator.providers` entry point.
+
+## Simulator Plugin
+
+When `python-getpaid-paynow[simulator]` is installed alongside
+`python-getpaid-simulator`, the simulator host auto-discovers the PayNow
+plugin.
+
+Typical local setup:
+
+```bash
+pip install python-getpaid-simulator python-getpaid-paynow[simulator]
+getpaid-simulator
+```
+
+The plugin contributes:
+
+- PayNow payment and refund simulator API routes under `/paynow/v3/...`
+- PayNow authorization UI at `/sim/paynow/authorize/{payment_id}`
+- PayNow-specific webhook signing and state transitions
+
+Useful simulator environment variables:
+
+- `SIMULATOR_PAYNOW_API_KEY`
+- `SIMULATOR_PAYNOW_SIGNATURE_KEY`
+- `SIMULATOR_PAYNOW_NOTIFY_URL`
+- `SIMULATOR_PLUGIN_FAILURE_MODE` (`warn` or `strict`)
+
 ## Quick Usage
 
 ### Standalone Client

{python_getpaid_paynow-3.0.0a3 → python_getpaid_paynow-3.0.0a4}/README.md

@@ -41,6 +41,42 @@ Install the package using pip:
 pip install python-getpaid-paynow
 ```
 
+Install simulator support only when you want this package to register its local
+simulator plugin with `python-getpaid-simulator`:
+
+```bash
+pip install python-getpaid-paynow[simulator]
+```
+
+This extra installs the simulator host and Litestar dependencies, then exposes
+the `paynow` plugin through the `getpaid.simulator.providers` entry point.
+
+## Simulator Plugin
+
+When `python-getpaid-paynow[simulator]` is installed alongside
+`python-getpaid-simulator`, the simulator host auto-discovers the PayNow
+plugin.
+
+Typical local setup:
+
+```bash
+pip install python-getpaid-simulator python-getpaid-paynow[simulator]
+getpaid-simulator
+```
+
+The plugin contributes:
+
+- PayNow payment and refund simulator API routes under `/paynow/v3/...`
+- PayNow authorization UI at `/sim/paynow/authorize/{payment_id}`
+- PayNow-specific webhook signing and state transitions
+
+Useful simulator environment variables:
+
+- `SIMULATOR_PAYNOW_API_KEY`
+- `SIMULATOR_PAYNOW_SIGNATURE_KEY`
+- `SIMULATOR_PAYNOW_NOTIFY_URL`
+- `SIMULATOR_PLUGIN_FAILURE_MODE` (`warn` or `strict`)
+
 ## Quick Usage
 
 ### Standalone Client

{python_getpaid_paynow-3.0.0a3 → python_getpaid_paynow-3.0.0a4}/pyproject.toml

@@ -23,6 +23,12 @@ dependencies = [
     'httpx>=0.27.0',
 ]
 
+[project.optional-dependencies]
+simulator = [
+    'python-getpaid-simulator>=3.0.0a3',
+    'litestar>=2.0',
+]
+
 [dependency-groups]
 dev = [
     'pytest>=8.0',
@@ -45,6 +51,9 @@ Changelog = 'https://github.com/django-getpaid/python-getpaid-paynow/releases'
 [project.entry-points."getpaid.backends"]
 paynow = 'getpaid_paynow.processor:PaynowProcessor'
 
+[project.entry-points."getpaid.simulator.providers"]
+paynow = 'getpaid_paynow.simulator:get_plugin'
+
 [build-system]
 requires = ['hatchling']
 build-backend = 'hatchling.build'

{python_getpaid_paynow-3.0.0a3 → python_getpaid_paynow-3.0.0a4}/src/getpaid_paynow/__init__.py

@@ -1,6 +1,6 @@
 """Paynow V3 payment gateway integration for python-getpaid ecosystem."""
 
-__version__ = "3.0.0a3"
+__version__ = "3.0.0a4"
 
 __all__ = [
     "PaynowClient",

python_getpaid_paynow-3.0.0a4/src/getpaid_paynow/simulator/__init__.py

@@ -0,0 +1,6 @@
+"""PayNow simulator plugin for python-getpaid-simulator."""
+
+from getpaid_paynow.simulator.plugin import get_plugin
+
+
+__all__ = ["get_plugin"]

python_getpaid_paynow-3.0.0a4/src/getpaid_paynow/simulator/plugin.py

@@ -0,0 +1,61 @@
+"""PayNow simulator plugin factory."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+from typing import Any
+
+from getpaid_simulator.spi import SIMULATOR_PLUGIN_API_VERSION
+from getpaid_simulator.spi import SimulatorProviderPlugin
+
+from getpaid_paynow.simulator.routes import cancel_refund
+from getpaid_paynow.simulator.routes import create_payment
+from getpaid_paynow.simulator.routes import create_refund
+from getpaid_paynow.simulator.routes import get_payment_methods
+from getpaid_paynow.simulator.routes import get_payment_status
+from getpaid_paynow.simulator.routes import get_refund_status
+from getpaid_paynow.simulator.routes import paynow_authorize_get
+from getpaid_paynow.simulator.routes import paynow_authorize_post
+from getpaid_paynow.simulator.transitions import PAYNOW_TRANSITIONS
+
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+def load_provider_config(
+    env: Mapping[str, str] | None = None,
+) -> dict[str, Any]:
+    environment = env or os.environ
+    return {
+        "api_key": environment.get(
+            "SIMULATOR_PAYNOW_API_KEY",
+            "sim-paynow-api-key",
+        ),
+        "signature_key": environment.get(
+            "SIMULATOR_PAYNOW_SIGNATURE_KEY",
+            "sim-paynow-key-default",
+        ),
+        "notify_url": environment.get("SIMULATOR_PAYNOW_NOTIFY_URL", ""),
+    }
+
+
+def get_plugin() -> SimulatorProviderPlugin:
+    return SimulatorProviderPlugin(
+        api_version=SIMULATOR_PLUGIN_API_VERSION,
+        slug="paynow",
+        display_name="PayNow",
+        api_handlers=(
+            create_payment,
+            get_payment_status,
+            get_payment_methods,
+            create_refund,
+            get_refund_status,
+            cancel_refund,
+        ),
+        ui_handlers=(paynow_authorize_get, paynow_authorize_post),
+        transitions=PAYNOW_TRANSITIONS,
+        load_config=load_provider_config,
+        authorize_path_template="/sim/paynow/authorize/{entity_id}",
+    )

python_getpaid_paynow-3.0.0a4/src/getpaid_paynow/simulator/routes.py

@@ -0,0 +1,406 @@
+"""PayNow simulator routes."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+from typing import TypedDict
+from typing import cast
+
+from litestar import Request
+from litestar import get
+from litestar import post
+from litestar.enums import MediaType
+from litestar.enums import RequestEncodingType
+from litestar.exceptions import HTTPException
+from litestar.exceptions import NotFoundException
+from litestar.params import Body
+from litestar.response import Redirect
+from litestar.response import Response
+from litestar.response import Template
+
+from getpaid_paynow.simulator.webhooks import trigger_paynow_webhook
+
+
+logger = logging.getLogger(__name__)
+URL_ENCODED_BODY = Body(media_type=RequestEncodingType.URL_ENCODED)
+
+PAYNOW_STATUSES = {
+    "NEW",
+    "PENDING",
+    "CONFIRMED",
+    "REJECTED",
+    "ERROR",
+    "EXPIRED",
+    "ABANDONED",
+}
+
+
+class PaynowError(TypedDict):
+    errorType: str
+    message: str
+
+
+class BuyerData(TypedDict, total=False):
+    email: str
+
+
+class PaymentMethod(TypedDict):
+    id: int
+    name: str
+    description: str
+    image: str
+    status: str
+    authorizationType: str
+
+
+class PaymentMethodGroup(TypedDict):
+    type: str
+    paymentMethods: list[PaymentMethod]
+
+
+class CreatePaymentPayload(TypedDict, total=False):
+    amount: int
+    currency: str
+    externalId: str
+    description: str
+    buyer: BuyerData
+    status: str
+
+
+PAYMENT_METHODS: list[PaymentMethodGroup] = [
+    {
+        "type": "PBL",
+        "paymentMethods": [
+            {
+                "id": 2001,
+                "name": "mTransfer",
+                "description": "mBank",
+                "image": "https://static.paynow.pl/payment-method-icons/2001.png",
+                "status": "ENABLED",
+                "authorizationType": "REDIRECT",
+            }
+        ],
+    },
+    {
+        "type": "CARD",
+        "paymentMethods": [
+            {
+                "id": 3001,
+                "name": "Visa",
+                "description": "Visa",
+                "image": "https://static.paynow.pl/payment-method-icons/3001.png",
+                "status": "ENABLED",
+                "authorizationType": "REDIRECT",
+            }
+        ],
+    },
+    {
+        "type": "BLIK",
+        "paymentMethods": [
+            {
+                "id": 5001,
+                "name": "BLIK",
+                "description": "BLIK",
+                "image": "https://static.paynow.pl/payment-method-icons/5001.png",
+                "status": "ENABLED",
+                "authorizationType": "CODE",
+            }
+        ],
+    },
+]
+
+
+def _provider_config(request: Request[Any, Any, Any]) -> dict[str, Any]:
+    return dict(request.app.state.provider_configs["paynow"])
+
+
+def _error_response(
+    status_code: int,
+    error_type: str,
+    message: str,
+) -> Response[object]:
+    return Response(
+        content={
+            "statusCode": status_code,
+            "errors": [{"errorType": error_type, "message": message}],
+        },
+        status_code=status_code,
+        media_type=MediaType.JSON,
+    )
+
+
+def _warn_if_signature_missing(request: Request[Any, Any, Any]) -> None:
+    if request.headers.get("signature"):
+        return
+    logger.warning("Signature header missing for PayNow request")
+
+
+def _validate_create_payload(payload: object) -> list[str]:
+    if not isinstance(payload, dict):
+        return ["Request body must be an object"]
+
+    typed_payload = cast("CreatePaymentPayload", cast("object", payload))
+    required_fields = [
+        "amount",
+        "currency",
+        "externalId",
+        "description",
+        "buyer",
+    ]
+    errors = [
+        f"Field '{field_name}' is required"
+        for field_name in required_fields
+        if field_name not in typed_payload
+    ]
+
+    buyer = typed_payload.get("buyer")
+    if "buyer" in typed_payload and (
+        not isinstance(buyer, dict) or not buyer.get("email")
+    ):
+        errors.append("Field 'buyer.email' is required")
+
+    amount = typed_payload.get("amount")
+    if "amount" in typed_payload and not isinstance(amount, int):
+        errors.append("Field 'amount' must be an integer")
+
+    status = typed_payload.get("status", "NEW")
+    if status not in PAYNOW_STATUSES:
+        errors.append("Field 'status' has invalid value")
+    return errors
+
+
+@post("/paynow/v3/payments")
+async def create_payment(
+    request: Request[Any, Any, Any],
+) -> Response[object]:
+    _warn_if_signature_missing(request)
+
+    payload_object: object = await request.json()
+    validation_errors = _validate_create_payload(payload_object)
+    if validation_errors:
+        return _error_response(400, "VALIDATION_ERROR", validation_errors[0])
+
+    payload = cast("CreatePaymentPayload", payload_object)
+    payment_data = dict(payload)
+    payment_data["status"] = str(payload.get("status", "NEW"))
+
+    provider_config = _provider_config(request)
+    notify_url = provider_config.get("notify_url")
+    if notify_url:
+        payment_data["notifyUrl"] = notify_url
+
+    payment_id = request.app.state.storage.create_order(
+        payment_data,
+        provider="paynow",
+    )
+
+    host = request.headers.get("host", "localhost")
+    redirect_url = f"http://{host}/sim/paynow/authorize/{payment_id}"
+    response_body = {
+        "redirectUrl": redirect_url,
+        "paymentId": payment_id,
+        "status": payment_data["status"],
+    }
+    return Response(
+        content=response_body,
+        status_code=201,
+        media_type=MediaType.JSON,
+    )
+
+
+@get("/paynow/v3/payments/{payment_id:str}/status")
+async def get_payment_status(
+    request: Request[Any, Any, Any],
+    payment_id: str,
+) -> Response[object]:
+    _warn_if_signature_missing(request)
+
+    payment = request.app.state.storage.get_order(payment_id)
+    if payment is None or payment.get("provider") != "paynow":
+        return _error_response(
+            404, "NOT_FOUND", f"Payment {payment_id} not found"
+        )
+
+    return Response(
+        content={
+            "paymentId": payment_id,
+            "status": str(payment.get("status", "NEW")),
+        },
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@get("/paynow/v3/payments/paymentmethods")
+async def get_payment_methods(
+    request: Request[Any, Any, Any],
+) -> Response[object]:
+    _warn_if_signature_missing(request)
+    return Response(
+        content=PAYMENT_METHODS, status_code=200, media_type=MediaType.JSON
+    )
+
+
+@post("/paynow/v3/payments/{payment_id:str}/refunds")
+async def create_refund(
+    request: Request[Any, Any, Any],
+    payment_id: str,
+) -> Response[object]:
+    _warn_if_signature_missing(request)
+
+    payment = request.app.state.storage.get_order(payment_id)
+    if payment is None or payment.get("provider") != "paynow":
+        return _error_response(
+            404, "NOT_FOUND", f"Payment {payment_id} not found"
+        )
+
+    payment_status = payment.get("status", "NEW")
+    if payment_status != "CONFIRMED":
+        return _error_response(
+            400,
+            "VALIDATION_ERROR",
+            f"Payment not in CONFIRMED status (current: {payment_status})",
+        )
+
+    payload = await request.json()
+    if not isinstance(payload, dict):
+        payload = {}
+
+    amount = payload.get("amount")
+    reason = payload.get("reason")
+    if amount is None:
+        return _error_response(
+            400, "VALIDATION_ERROR", "Field 'amount' is required"
+        )
+
+    refund_data = {"amount": amount, "status": "SUCCESSFUL"}
+    if reason is not None:
+        refund_data["reason"] = reason
+
+    refund_id = request.app.state.storage.create_refund(payment_id, refund_data)
+    return Response(
+        content={"refundId": refund_id, "status": "SUCCESSFUL"},
+        status_code=201,
+        media_type=MediaType.JSON,
+    )
+
+
+@get("/paynow/v3/refunds/{refund_id:str}/status")
+async def get_refund_status(
+    request: Request[Any, Any, Any],
+    refund_id: str,
+) -> Response[object]:
+    _warn_if_signature_missing(request)
+
+    refund = request.app.state.storage.get_refund(refund_id)
+    if refund is None:
+        return _error_response(
+            404, "NOT_FOUND", f"Refund {refund_id} not found"
+        )
+
+    amount = refund.get("amount")
+    if isinstance(amount, str):
+        amount = int(amount)
+    return Response(
+        content={
+            "refundId": refund_id,
+            "status": str(refund.get("status", "SUCCESSFUL")),
+            "amount": amount,
+        },
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@post("/paynow/v3/refunds/{refund_id:str}/cancel")
+async def cancel_refund(
+    request: Request[Any, Any, Any],
+    refund_id: str,
+) -> Response[object]:
+    _warn_if_signature_missing(request)
+
+    refund = request.app.state.storage.get_refund(refund_id)
+    if refund is None:
+        return _error_response(
+            404, "NOT_FOUND", f"Refund {refund_id} not found"
+        )
+
+    request.app.state.storage.update_refund(refund_id, status="CANCELLED")
+    return Response(
+        content={"refundId": refund_id, "status": "CANCELLED"},
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@get("/sim/paynow/authorize/{payment_id:str}")
+async def paynow_authorize_get(
+    payment_id: str,
+    request: Request[Any, Any, Any],
+) -> Template:
+    payment = request.app.state.storage.get_order(payment_id)
+    if not payment:
+        raise NotFoundException("Payment not found")
+
+    if payment.get("status") in ("CONFIRMED", "REJECTED"):
+        raise HTTPException(status_code=400, detail="Payment already processed")
+
+    amount_raw = payment.get("amount", payment.get("totalAmount", 0))
+    try:
+        amount_value = float(amount_raw) / 100
+        formatted_amount = (
+            f"{amount_value:.2f} "
+            f"{payment.get('currency', payment.get('currencyCode', 'PLN'))}"
+        )
+    except (ValueError, TypeError):
+        formatted_amount = str(amount_raw)
+
+    return Template(
+        template_name="authorize.html",
+        context={
+            "provider": "PayNow",
+            "payment": payment,
+            "payment_id": payment_id,
+            "order_id": payment_id,
+            "amount": formatted_amount,
+            "status": payment.get("status", "NEW"),
+        },
+    )
+
+
+@post("/sim/paynow/authorize/{payment_id:str}")
+async def paynow_authorize_post(
+    payment_id: str,
+    request: Request[Any, Any, Any],
+    data: dict[str, str] = URL_ENCODED_BODY,
+) -> Redirect:
+    payment = request.app.state.storage.get_order(payment_id)
+    if not payment:
+        raise NotFoundException("Payment not found")
+
+    current_status = payment.get("status", "NEW")
+    if current_status in ("CONFIRMED", "REJECTED"):
+        raise HTTPException(status_code=400, detail="Payment already processed")
+
+    action = data.get("action")
+    if action == "approve":
+        if current_status == "NEW":
+            request.app.state.state_machine.transition(payment_id, "PENDING")
+        request.app.state.state_machine.transition(payment_id, "CONFIRMED")
+    elif action == "reject":
+        if current_status == "NEW":
+            request.app.state.state_machine.transition(payment_id, "PENDING")
+        request.app.state.state_machine.transition(payment_id, "REJECTED")
+    else:
+        raise HTTPException(status_code=400, detail="Invalid action")
+
+    await trigger_paynow_webhook(
+        payment_id,
+        request.app.state.storage,
+        _provider_config(request),
+        request.app.state.webhook_transport,
+    )
+
+    continue_url = payment.get("continueUrl", "/sim/dashboard")
+    return Redirect(path=str(continue_url))

python_getpaid_paynow-3.0.0a4/src/getpaid_paynow/simulator/signing.py

@@ -0,0 +1,49 @@
+"""PayNow signing helpers for the simulator plugin."""
+
+import base64
+import hashlib
+import hmac
+import json
+
+
+def calculate_notification_signature(body: str, signature_key: str) -> str:
+    digest = hmac.new(
+        signature_key.encode("utf-8"),
+        body.encode("utf-8"),
+        hashlib.sha256,
+    ).digest()
+    return base64.b64encode(digest).decode("utf-8")
+
+
+def calculate_request_signature(
+    api_key: str,
+    idempotency_key: str,
+    body: str,
+    signature_key: str,
+    parameters: dict[str, str] | None = None,
+) -> str:
+    params = parameters or {}
+    headers_dict = {
+        "Api-Key": api_key,
+        "Idempotency-Key": idempotency_key,
+    }
+    payload = {
+        "headers": dict(sorted(headers_dict.items())),
+        "parameters": dict(sorted(params.items())),
+        "body": body,
+    }
+    payload_json = json.dumps(payload, separators=(",", ":"))
+    digest = hmac.new(
+        signature_key.encode("utf-8"),
+        payload_json.encode("utf-8"),
+        hashlib.sha256,
+    ).digest()
+    return base64.b64encode(digest).decode("utf-8")
+
+
+def sign_webhook(body: bytes, signature_key: str) -> dict[str, str]:
+    signature = calculate_notification_signature(
+        body.decode("utf-8"),
+        signature_key,
+    )
+    return {"Signature": signature}

python_getpaid_paynow-3.0.0a4/src/getpaid_paynow/simulator/transitions.py

@@ -0,0 +1,17 @@
+"""PayNow simulator state transitions."""
+
+PAYNOW_TRANSITIONS: dict[str, set[str]] = {
+    "NEW": {"PENDING", "ABANDONED"},
+    "PENDING": {
+        "CONFIRMED",
+        "REJECTED",
+        "ERROR",
+        "EXPIRED",
+        "ABANDONED",
+    },
+    "CONFIRMED": set(),
+    "REJECTED": set(),
+    "ERROR": set(),
+    "EXPIRED": set(),
+    "ABANDONED": set(),
+}

python_getpaid_paynow-3.0.0a4/src/getpaid_paynow/simulator/webhooks.py

@@ -0,0 +1,59 @@
+"""PayNow webhook delivery for the simulator plugin."""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC
+from datetime import datetime
+from typing import TYPE_CHECKING
+from typing import Any
+
+from getpaid_paynow.simulator.signing import sign_webhook
+
+
+if TYPE_CHECKING:
+    from getpaid_simulator.core.storage import SimulatorStorage
+    from getpaid_simulator.core.webhooks import WebhookTransport
+
+
+def build_notification_payload(
+    payment_id: str,
+    payment: dict[str, Any],
+) -> dict[str, Any]:
+    return {
+        "paymentId": payment_id,
+        "externalId": payment.get("externalId", ""),
+        "status": payment.get("status", "NEW"),
+        "modifiedAt": datetime.now(UTC).isoformat(),
+    }
+
+
+async def trigger_paynow_webhook(
+    payment_id: str,
+    storage: SimulatorStorage,
+    provider_config: dict[str, Any],
+    transport: WebhookTransport,
+) -> bool | None:
+    payment = storage.get_order(payment_id)
+    if payment is None:
+        return None
+
+    notify_url = payment.get("notifyUrl") or provider_config.get("notify_url")
+    if not notify_url:
+        return None
+
+    payload = build_notification_payload(payment_id, payment)
+    body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+    headers = {
+        "Content-Type": "application/json",
+        **sign_webhook(body, str(provider_config["signature_key"])),
+    }
+
+    result = await transport.deliver(
+        url=str(notify_url), body=body, headers=headers
+    )
+    storage.update_order(
+        payment_id,
+        webhook_status="success" if result else "failed",
+    )
+    return result

{python_getpaid_paynow-3.0.0a3 → python_getpaid_paynow-3.0.0a4}/tests/test_public_api.py

@@ -4,4 +4,4 @@ import getpaid_paynow
 
 
 def test_version() -> None:
-    assert getpaid_paynow.__version__ == "3.0.0a3"
+    assert getpaid_paynow.__version__ == "3.0.0a4"

python_getpaid_paynow-3.0.0a4/tests/test_simulator_plugin.py

@@ -0,0 +1,158 @@
+"""Tests for the PayNow simulator plugin."""
+
+from __future__ import annotations
+
+import json
+from importlib.metadata import entry_points
+
+import pytest
+from getpaid_simulator.spi import SIMULATOR_PLUGIN_API_VERSION
+
+from getpaid_paynow.simulator import get_plugin
+from getpaid_paynow.simulator.plugin import load_provider_config
+from getpaid_paynow.simulator.signing import sign_webhook
+from getpaid_paynow.simulator.webhooks import trigger_paynow_webhook
+
+
+def _handler_name(handler: object) -> str:
+    return str(handler.fn.__name__)
+
+
+class FakeStorage:
+    def __init__(self, payment: dict[str, object] | None) -> None:
+        self.payment = payment
+        self.updated: dict[str, object] = {}
+
+    def get_order(self, payment_id: str) -> dict[str, object] | None:
+        if self.payment is None or payment_id != "payment-1":
+            return None
+        return dict(self.payment)
+
+    def update_order(self, payment_id: str, **updates: object) -> None:
+        assert payment_id == "payment-1"
+        self.updated = dict(updates)
+
+
+class FakeTransport:
+    def __init__(self, result: bool = True) -> None:
+        self.result = result
+        self.calls: list[dict[str, object]] = []
+
+    async def deliver(
+        self,
+        *,
+        url: str,
+        body: bytes,
+        headers: dict[str, str],
+    ) -> bool:
+        self.calls.append({"url": url, "body": body, "headers": dict(headers)})
+        return self.result
+
+
+def test_paynow_simulator_entry_point_registered() -> None:
+    simulator_plugins = [
+        entry_point
+        for entry_point in entry_points(group="getpaid.simulator.providers")
+        if entry_point.name == "paynow"
+    ]
+
+    assert len(simulator_plugins) == 1
+    assert simulator_plugins[0].value == "getpaid_paynow.simulator:get_plugin"
+
+
+def test_get_plugin_returns_paynow_simulator_descriptor() -> None:
+    plugin = get_plugin()
+
+    assert plugin.api_version == SIMULATOR_PLUGIN_API_VERSION
+    assert plugin.slug == "paynow"
+    assert plugin.display_name == "PayNow"
+    assert plugin.authorize_path_template == "/sim/paynow/authorize/{entity_id}"
+    assert (
+        plugin.build_authorize_path("payment-123")
+        == "/sim/paynow/authorize/payment-123"
+    )
+    assert {_handler_name(handler) for handler in plugin.api_handlers} == {
+        "create_payment",
+        "get_payment_status",
+        "get_payment_methods",
+        "create_refund",
+        "get_refund_status",
+        "cancel_refund",
+    }
+    assert {_handler_name(handler) for handler in plugin.ui_handlers} == {
+        "paynow_authorize_get",
+        "paynow_authorize_post",
+    }
+
+
+def test_load_provider_config_reads_env_overrides(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("SIMULATOR_PAYNOW_API_KEY", "override-api-key")
+    monkeypatch.setenv("SIMULATOR_PAYNOW_SIGNATURE_KEY", "override-signature")
+    monkeypatch.setenv(
+        "SIMULATOR_PAYNOW_NOTIFY_URL",
+        "https://merchant.example/paynow/callback",
+    )
+
+    assert load_provider_config() == {
+        "api_key": "override-api-key",
+        "signature_key": "override-signature",
+        "notify_url": "https://merchant.example/paynow/callback",
+    }
+
+
+@pytest.mark.asyncio
+async def test_trigger_paynow_webhook_uses_provider_notify_url_fallback() -> (
+    None
+):
+    storage = FakeStorage(
+        {
+            "externalId": "PAYNOW-42",
+            "status": "CONFIRMED",
+        }
+    )
+    transport = FakeTransport()
+
+    result = await trigger_paynow_webhook(
+        "payment-1",
+        storage,
+        {
+            "signature_key": "secret-key",
+            "notify_url": "https://merchant.example/paynow/callback",
+        },
+        transport,
+    )
+
+    assert result is True
+    assert storage.updated == {"webhook_status": "success"}
+    assert len(transport.calls) == 1
+
+    request = transport.calls[0]
+    assert request["url"] == "https://merchant.example/paynow/callback"
+    body = request["body"]
+    assert isinstance(body, bytes)
+    payload = json.loads(body)
+    assert payload["paymentId"] == "payment-1"
+    assert payload["externalId"] == "PAYNOW-42"
+    assert payload["status"] == "CONFIRMED"
+    assert request["headers"] == {
+        "Content-Type": "application/json",
+        **sign_webhook(body, "secret-key"),
+    }
+
+
+@pytest.mark.asyncio
+async def test_trigger_paynow_webhook_returns_none_without_target() -> None:
+    storage = FakeStorage({"externalId": "PAYNOW-42", "status": "CONFIRMED"})
+    transport = FakeTransport()
+
+    result = await trigger_paynow_webhook(
+        "payment-1",
+        storage,
+        {"signature_key": "secret-key", "notify_url": ""},
+        transport,
+    )
+
+    assert result is None
+    assert transport.calls == []