python-redsys 1.2.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

python_redsys-1.2.2.dist-info/METADATA

@@ -1,122 +0,0 @@
-Metadata-Version: 2.4
-Name: python-redsys
-Version: 1.2.2
-Summary: A simple, lightweight client to handle payments through the RedSys platform.
-License: MIT
-License-File: LICENSE
-Author: David Díaz
-Author-email: d.diazp@gmail.com
-Requires-Python: >=3.8,<4.0
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: 3.15
-Requires-Dist: pycryptodome (>=3.19.1,<4.0.0)
-Project-URL: Homepage, https://github.com/ddiazpinto/python-redsys
-Description-Content-Type: text/markdown
-
-# Welcome to python-redsys!
-
-[![CI](https://github.com/ddiazpinto/python-redsys/actions/workflows/python-app.yml/badge.svg?branch=release/1.x)](https://github.com/ddiazpinto/python-redsys/actions/workflows/python-app.yml?query=branch%3Arelease%2F1.x) [![PyPI](https://img.shields.io/pypi/v/python-redsys.svg)](https://pypi.org/project/python-redsys/) ![Python 3.8+](https://img.shields.io/badge/python-3.8%2B-blue.svg) [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/ddiazpinto/python-redsys/blob/release/1.x/LICENSE)
-
-A simple, lightweight client to handle payments through the RedSys platform, using its *redirect connection* (browser form POST).
-
-The library only builds the signed request and verifies/parses the response. It makes no network or browser calls of its own: the payment form is submitted from the cardholder's browser.
-
-## Installation
-
-```bash
-pip install "python-redsys>=1.2,<2"
-
-# or with Poetry
-poetry add "python-redsys@^1.2"
-```
-
-Requires Python 3.8+. Runtime dependency: `pycryptodome`.
-
-## Usage
-
-The client prepares a request from a dict of parameters and verifies the response. Parameter values are validated on construction (`ValueError` on an unknown parameter or an invalid value, `TypeError` when `amount` is not a `Decimal`); `order` has 12 characters (4 digits followed by 8 alphanumerics), and `amount` is a `Decimal`, serialized to integer minor units on the wire. The allowed values for `currency`, `transaction_type` and `consumer_language` are in `redsys.constants`.
-
-## Using *redirect connection*
-
-### 1. Build a signed request
-
-```python
-from decimal import Decimal, ROUND_HALF_UP
-from redsys.client import RedirectClient
-from redsys.constants import EUR, STANDARD_PAYMENT
-
-client = RedirectClient(secret_key="sq7HjrUOBfKmC576ILgskD5srU870gJ7")
-
-post_parameters = client.prepare_request({
-    "merchant_code": "999008881",
-    "terminal": "1",
-    "transaction_type": STANDARD_PAYMENT,
-    "currency": EUR,
-    "order": "000000000001",
-    # The amount is a Decimal; pre-quantize to two decimals.
-    "amount": Decimal("10.56489").quantize(Decimal(".01"), ROUND_HALF_UP),
-    "merchant_url": "https://example.com/redsys/response",
-    "url_ok": "https://example.com/ok",
-    "url_ko": "https://example.com/ko",
-    "merchant_name": "Example Commerce",
-    "product_description": "Products of Example Commerce",
-})  # Ds_SignatureVersion / Ds_MerchantParameters / Ds_Signature
-```
-
-The secret key, merchant code `999008881` and terminal `1` are the RedSys public test merchant's. `Ds_MerchantParameters` and `Ds_Signature` are returned as `bytes`; decode them before rendering them in an HTML form.
-
-Bizum: add `"payment_method": "z"` (and optionally `"mobile_number"`) to the parameters.
-
-### 2. Communication step
-
-Auto-submit an HTML form (`method="POST"`) with the three `post_parameters` fields to the RedSys endpoint:
-
-- Test: `https://sis-t.redsys.es:25443/sis/realizarPago`
-- Production: `https://sis.redsys.es/sis/realizarPago`
-
-RedSys notifies the result both as a server-to-server POST to `merchant_url` and as a browser redirect to `url_ok` / `url_ko`.
-
-### 3. Verify and read the response
-
-`create_response()` takes the received `Ds_Signature` and `Ds_MerchantParameters` and raises `ValueError` on signature mismatch.
-
-```python
-response = client.create_response(signature, merchant_parameters)  # as RedSys posted them back
-
-if response.is_paid:
-    ...  # actions after a successful payment
-else:
-    raise Exception(f"declined with code {response.code}")
-```
-
-Response predicates (per the RedSys documentation):
-
-- `response.is_paid`: response code between 0 and 99.
-- `response.is_canceled`: response code 400.
-- `response.is_refunded`: response code 900.
-- `response.is_authorized`: paid, refunded or canceled.
-
-`response.code` is the RedSys code as an `int`, and `response.message` its Spanish description (`None` for a code without one). Decoded fields (`response.order`, `response.amount` as a `Decimal`, ...) read as attributes, `None` when absent; `response.parameters` holds every decoded parameter: listed ones under their attribute name (`amount`), unlisted ones under their original `Ds_*` key.
-
-## Signature version
-
-The 1.x line signs with `HMAC_SHA256_V1` (3DES + HMAC-SHA256), the legacy scheme still accepted by RedSys. `HMAC_SHA512_V1` requires 2.x.
-
-## Support
-
-The 1.x line receives fixes until 2026-12-31.
-
-## Contributing
-
-Contributions that keep the *lightweight* philosophy are welcome.
-

python_redsys-1.2.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-redsys/__init__.py,sha256=k234cuEigYkeydQvG5NyAl4pPAyCQSjL65UvOkeTak8,138
-redsys/client.py,sha256=ervLX4FbzDfWjh_SO2SFyY9IT0PZ5aIcVZdYy4mUO7Q,3937
-redsys/constants.py,sha256=lJYgbmikxh0b9iVM4M5XFWBWVvdFY27OkcXSLluHSsQ,2497
-redsys/request.py,sha256=IEzlRi34JgDBRRyaBHtIrAZ38fADL977RdBFaeWDdbY,5304
-redsys/response.py,sha256=YDihLSIE388Ib53qr9PUtGsWqLqj1zFdjbgn9x_i-8A,5585
-redsys/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-redsys/tests/test_client.py,sha256=oND8W9y6O6MkDLNxnBpd8UDShwKWoAW3SgKmWDOXHrw,3858
-redsys/tests/test_request.py,sha256=FONigjMNdaug2DwillYKCLPK-gzIYZSVUZmcm9QkCms,3110
-redsys/tests/test_response.py,sha256=K1QP7eRyBum88LXG6IOQtno8FZNxoVHUv-GJU83k5OI,1777
-python_redsys-1.2.2.dist-info/METADATA,sha256=PXqNlioj4tNFrfUXhiPZ1P77pgIJne39Q_oD4sXto4U,5517
-python_redsys-1.2.2.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
-python_redsys-1.2.2.dist-info/licenses/LICENSE,sha256=Ku6mJcUOcHd2aZ4o2Jh4Tjkx1oZT-iT0VCyUNvm2IXU,1257
-python_redsys-1.2.2.dist-info/RECORD,,

python_redsys-1.2.2.dist-info/licenses/LICENSE

@@ -1,25 +0,0 @@
-MIT License
- 
-The original development of python-redsys is copyrighted to David Díaz.
-Copyright (c) 2016 David Díaz
-
-Extensions to python-redsys are copyrighted to Andrés Reverón Molina.
-Copyright (c) 2021 Andrés Reverón Molina
-
-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.

redsys/client.py

@@ -1,105 +0,0 @@
-import base64
-import hashlib
-import hmac
-import json
-import re
-from abc import ABC
-from abc import abstractmethod
-from typing import Any
-from typing import Dict
-
-from Crypto.Cipher import DES3
-
-from redsys.request import Request
-from redsys.response import Response
-
-# Calculated parameters
-SIGNATURE_VERSION = "Ds_SignatureVersion"
-MERCHANT_PARAMETERS = "Ds_MerchantParameters"
-SIGNATURE = "Ds_Signature"
-DEFAULT_SIGNATURE_VERSION = "HMAC_SHA256_V1"
-
-
-class Client(ABC):
-    """
-    Abstract class from which RedirectClient inherits.
-    It implements methods that may be used in future clients(i.e. rest).
-    """
-
-    def __init__(self, secret_key: str):
-        self.secret_key: bytes = secret_key.encode()
-
-    @abstractmethod
-    def create_response(self, signature, parameters):
-        raise NotImplementedError
-
-    @abstractmethod
-    def prepare_request(self, request):
-        raise NotImplementedError
-
-    @staticmethod
-    def encode_parameters(parameters: Dict[str, Any]) -> bytes:
-        """Encodes the merchant parameters in base64"""
-        return base64.b64encode(json.dumps(parameters).encode())
-
-    @staticmethod
-    def decode_parameters(parameters: bytes) -> Dict[str, Any]:
-        """Decodes the merchant parameters from base64"""
-        return json.loads(base64.b64decode(parameters).decode())
-
-    @staticmethod
-    def sign_hmac256(encrypted_order: bytes, merchant_parameters: bytes) -> bytes:
-        """
-        Generates the encrypted signature using the 3DES-encrypted order
-        and base64-encoded merchant parameters
-        """
-        signature = hmac.new(encrypted_order, merchant_parameters, hashlib.sha256).digest()
-        return base64.b64encode(signature)
-
-    def encrypt_3DES(self, order: str) -> bytes:
-        """Encrypts(3DES algorithm) the payment order using the secret key"""
-        cipher = DES3.new(base64.b64decode(self.secret_key), DES3.MODE_CBC, IV=b"\0\0\0\0\0\0\0\0")
-        # the cipher needs to be passed 16 bytes,
-        # so "order" must be 16 bytes long,
-        # therefore we left-justify adding ceros
-        return cipher.encrypt(order.encode().ljust(16, b"\0"))
-
-    def generate_signature(self, order: str, merchant_parameters: bytes) -> bytes:
-        return self.sign_hmac256(self.encrypt_3DES(order), merchant_parameters)
-
-
-class RedirectClient(Client):
-    def prepare_request(self, parameters: Dict[str, Any]) -> Dict[str, Any]:
-        """Takes the merchant parameters and returns the necessary parameters
-        to make the POST request to Redsys"""
-        request = Request(parameters)
-        merchant_parameters = self.encode_parameters(request.prepare_parameters())
-        signature = self.generate_signature(request.order, merchant_parameters)
-        return {
-            SIGNATURE_VERSION: DEFAULT_SIGNATURE_VERSION,
-            MERCHANT_PARAMETERS: merchant_parameters,
-            SIGNATURE: signature,
-        }
-
-    def create_response(
-        self,
-        signature: str,
-        merchant_parameters: str,
-    ) -> Response:
-        """
-        Decodes the Redsys response to check for validity.
-        Checks if the received signature corresponds to the sent signature.
-
-        Both the `signature` and `merchant parameters` are plain strings, not bytes.
-        """
-        decoded_parameters = self.decode_parameters(merchant_parameters.encode())
-        response = Response(decoded_parameters)
-        calculated_signature = self.generate_signature(response.order, merchant_parameters.encode())
-        # Remove any non-alphanumeric characters from the signature
-        not_alphanumeric = re.compile("[^a-zA-Z0-9]")
-        safe_signature = re.sub(not_alphanumeric, "", signature)
-
-        safe_calculated_signature = re.sub(not_alphanumeric, "", calculated_signature.decode())
-        if safe_signature != safe_calculated_signature:
-            raise ValueError("The provided signature is not valid.")
-        return response

redsys/constants.py

@@ -1,113 +0,0 @@
-# Currencies
-""" Euro """
-EUR = 978
-""" United States dollar """
-USD = 840
-""" Pound sterling """
-GBP = 826
-""" Japanese yen """
-JPY = 392
-""" Argentine peso """
-ARS = 32
-""" Canadian dollar """
-CAD = 124
-""" Chilean Peso """
-CLP = 152
-""" Colombian peso """
-COP = 170
-""" Indian rupee """
-INR = 356
-""" Mexican peso """
-MXN = 484
-""" Peruvian Sol """
-PEN = 604
-""" Swiss franc """
-CHF = 756
-""" Brazilian real """
-BRL = 986
-""" Venezuelan bolivar """
-VEF = 937
-""" Turkish lira """
-TRY = 949
-
-CURRENCIES = [EUR, USD, GBP, JPY, ARS, CAD, CLP, COP, INR, MXN, PEN, CHF, BRL, VEF, TRY]
-
-# Languages
-CUSTOMER = "000"
-SPANISH = "001"
-ENGLISH = "002"
-CATALAN = "003"
-FRENCH = "004"
-GERMAN = "005"
-DUTCH = "006"
-ITALIAN = "007"
-SWEDISH = "008"
-PORTUGUESE = "009"
-VALENCIAN = "010"
-POLISH = "011"
-GALICIAN = "012"
-EUSKERA = "013"
-
-LANGUAGES = [
-    CUSTOMER,
-    SPANISH,
-    ENGLISH,
-    CATALAN,
-    FRENCH,
-    GERMAN,
-    DUTCH,
-    ITALIAN,
-    SWEDISH,
-    PORTUGUESE,
-    VALENCIAN,
-    POLISH,
-    GALICIAN,
-    EUSKERA,
-]
-
-# Transaction types
-""" Standard payment """
-STANDARD_PAYMENT = "0"
-""" Pre-authorization """
-PREAUTHORIZATION = "1"
-""" Confirmation of pre-authorization """
-PREAUTHORIZATION_CONFIRMATION = "2"
-""" Partial or total refund """
-REFUND = "3"
-""" Recurring transaction """
-RECURRING_TRANSACTION = "5"
-""" Successive transaction """
-SUCCESSIVE_TRANSACTION = "6"
-""" Authentication """
-AUTHENTICATION = "7"
-""" Confirmation of authentication """
-AUTHENTICATION_CONFIRMATION = "8"
-""" Cancellation of pre-authorization """
-PREAUTHORIZATION_CANCELATION = "9"
-""" Deferred pre-authorization """
-DEFERRED_PREAUTHORIZATION = "O"
-""" Confirmation of deferred pre-authorization """
-DEFERRED_PREAUTHORIZATION_CONFIRMATION = "P"
-""" Cancelation of deferred pre-authorization """
-DEFERRED_PREAUTHORIZATION_CANCELATION = "Q"
-""" Recurring deferred pre-authorization """
-RECURRING_DEFERRED_PREAUTHORIZATION = "R"
-""" Confirmation of recurring deferred pre-authorization and successive transaction """
-SUCCESSIVE_RECURRING_TRANSACTION = "S"
-
-TRANSACTIONS = [
-    STANDARD_PAYMENT,
-    PREAUTHORIZATION,
-    PREAUTHORIZATION_CONFIRMATION,
-    REFUND,
-    RECURRING_TRANSACTION,
-    SUCCESSIVE_TRANSACTION,
-    AUTHENTICATION,
-    AUTHENTICATION_CONFIRMATION,
-    PREAUTHORIZATION_CANCELATION,
-    DEFERRED_PREAUTHORIZATION,
-    DEFERRED_PREAUTHORIZATION_CONFIRMATION,
-    DEFERRED_PREAUTHORIZATION_CANCELATION,
-    RECURRING_DEFERRED_PREAUTHORIZATION,
-    SUCCESSIVE_RECURRING_TRANSACTION,
-]

redsys/response.py

@@ -1,149 +0,0 @@
-from decimal import Decimal
-from typing import Any
-from typing import Dict
-
-RESPONSE = "Ds_Response"
-DATE = "Ds_Date"
-HOUR = "Ds_Hour"
-MERCHANT_CODE = "Ds_MerchantCode"
-TERMINAL = "Ds_Terminal"
-TRANSACTION_TYPE = "Ds_TransactionType"
-ORDER = "Ds_Order"
-CURRENCY = "Ds_Currency"
-AMOUNT = "Ds_Amount"
-MERCHANT_DATA = "Ds_MerchantData"
-CONSUMER_LANGUAGE = "Ds_ConsumerLanguage"
-CARD_COUNTRY = "Ds_Card_Country"
-CARD_TYPE = "Ds_Card_Type"
-CARD_BRAND = "Ds_Card_Brand"
-MERCHANT_COF_TXNID = "Ds_Merchant_Cof_Txnid"
-SECURE_PAYMENT = "Ds_SecurePayment"
-AUTHORIZATION_CODE = "Ds_AuthorisationCode"
-ERROR_CODE = "Ds_ErrorCode"
-AMOUNT_EURO = "Ds_Amount_Euro"
-PROCESSED_PAY_METHOD = "Ds_ProcessedPayMethod"
-
-RESPONSE_MAP = {
-    "0000": "Transacción autorizada para pagos y preautorizaciones",
-    "900": "Transacción autorizada para devoluciones y confirmaciones",
-    "400": "Transacción autorizada para anulaciones",
-    "101": "Tarjeta caducada",
-    "102": "Tarjeta en excepción transitoria o bajo sospecha de fraude",
-    "106": "Intentos de PIN excedidos",
-    "125": "Tarjeta no efectiva",
-    "129": "Código de seguridad (CVV2/CVC2) incorrecto",
-    "180": "Tarjeta ajena al servicio",
-    "184": "Error en la autenticación del titular",
-    "190": "Denegación del emisor sin especificar motivo",
-    "191": "Fecha de caducidad errónea",
-    "202": "Tarjeta en excepción transitoria o bajo sospecha de fraude con retirada de tarjeta",
-    "904": "Comercio no registrado en FUC",
-    "909": "Error de sistema",
-    "912": "Emisor no disponible",
-    "913": "Pedido repetido",
-    "944": "Sesión Incorrecta",
-    "950": "Operación de devolución no permitida",
-    "9912": "Emisor no disponible",
-    "9064": "Número de posiciones de la tarjeta incorrecto",
-    "9078": "Tipo de operación no permitida para esa tarjeta",
-    "9093": "Tarjeta no existente",
-    "9094": "Rechazo servidores internacionales",
-    "9104": "Comercio con “titular seguro” y titular sin clave de compra segura",
-    "9218": "El comercio no permite op. seguras por entrada /operaciones",
-    "9253": "Tarjeta no cumple el check-digit",
-    "9256": "El comercio no puede realizar preautorizaciones",
-    "9257": "Esta tarjeta no permite operativa de preautorizaciones",
-    "9261": "Operación detenida por superar el control de restricciones en la entrada al SIS",
-    "9913": "Error en la confirmación que el comercio envía al TPV Virtual",
-    "9914": "Confirmación “KO” del comercio",
-    "9915": "A petición del usuario se ha cancelado el pago",
-    "9928": "Anulación de autorización en diferido realizada por el SIS (proceso batch)",
-    "9929": "Anulación de autorización en diferido realizada por el comercio",
-    "9997": "Se está procesando otra transacción en SIS con la misma tarjeta",
-    "9998": "Operación en proceso de solicitud de datos de tarjeta",
-    "9999": "Operación que ha sido redirigida al emisor a autenticar",
-}
-
-MERCHANT_PARAMETERS_MAP = {
-    "response": RESPONSE,
-    "date": DATE,
-    "hour": HOUR,
-    "merchant_code": MERCHANT_CODE,
-    "terminal": TERMINAL,
-    "transaction_type": TRANSACTION_TYPE,
-    "order": ORDER,
-    "currency": CURRENCY,
-    "amount": AMOUNT,
-    "merchant_data": MERCHANT_DATA,
-    "consumer_language": CONSUMER_LANGUAGE,
-    "card_country": CARD_COUNTRY,
-    "card_type": CARD_TYPE,
-    "card_brand": CARD_BRAND,
-    "merchant_cof_txnid": MERCHANT_COF_TXNID,
-    "secure_payment": SECURE_PAYMENT,
-    "authorization_code": AUTHORIZATION_CODE,
-    "error_code": ERROR_CODE,
-    "amount_euro": AMOUNT_EURO,
-    "processed_pay_method": PROCESSED_PAY_METHOD,
-}
-
-
-class Response:
-    """
-    Defines a response
-    """
-
-    _parameters: Dict[str, Any]
-
-    def __init__(self, parameters: Dict[str, Any]):
-        # __setattr__ only handles merchant parameters, so the per-instance store is set directly.
-        object.__setattr__(self, "_parameters", {})
-        MERCHANT_PARAMETERS_MAP_REVERSE = {value: key for key, value in MERCHANT_PARAMETERS_MAP.items()}
-        for key, value in parameters.items():
-            reversed_parameter = MERCHANT_PARAMETERS_MAP_REVERSE.get(key, key)
-            clean = getattr(self, "clean_%s" % reversed_parameter, None)
-            self._parameters[reversed_parameter] = clean(value) if clean else value
-
-    def __getattr__(self, item: str) -> Any:
-        if item in MERCHANT_PARAMETERS_MAP:
-            return self._parameters.get(item)
-
-    def __setattr__(self, key: str, value: Any):
-        if key in MERCHANT_PARAMETERS_MAP:
-            clean = getattr(self, "clean_%s" % MERCHANT_PARAMETERS_MAP[key], None)
-            self._parameters[MERCHANT_PARAMETERS_MAP[key]] = clean(value) if clean else value
-
-    @property
-    def is_authorized(self):
-        return (0 <= self.code <= 99) or self.code == 900 or self.code == 400
-
-    @property
-    def is_paid(self):
-        return 0 <= self.code <= 99
-
-    @property
-    def is_refunded(self):
-        return self.code == 900
-
-    @property
-    def is_canceled(self):
-        return self.code == 400
-
-    @property
-    def code(self):
-        return int(self.response)
-
-    @property
-    def message(self):
-        if self.is_paid:
-            return RESPONSE_MAP["0000"]
-        # RedSys sends 4-digit codes ("0190"); the map keys drop the leading zeros ("190").
-        return RESPONSE_MAP.get(self.response) or RESPONSE_MAP.get(str(self.code))
-
-    @property
-    def parameters(self):
-        return self._parameters
-
-    @staticmethod
-    def clean_amount(value):
-        return Decimal(f"{str(value)[:-2]}.{str(value)[-2:]}")

redsys/tests/test_client.py

@@ -1,89 +0,0 @@
-from decimal import ROUND_HALF_UP
-from decimal import Decimal as D
-
-import pytest
-
-from redsys.client import RedirectClient
-from redsys.constants import EUR
-from redsys.constants import STANDARD_PAYMENT
-from redsys.request import Request
-
-
-class TestRedirectClient:
-    @pytest.fixture(autouse=True)
-    def set_up(self):
-        secret_key = "sq7HjrUOBfKmC576ILgskD5srU870gJ7"
-        self.client = RedirectClient(secret_key)
-        self.parameters = {
-            "merchant_code": "100000001",
-            "terminal": "1",
-            "transaction_type": STANDARD_PAYMENT,
-            "currency": EUR,
-            "order": "000000000001",
-            "amount": D("10.56489").quantize(D(".01"), ROUND_HALF_UP),
-            "merchant_data": "test merchant data",
-            "merchant_name": "Example Commerce",
-            "titular": "Example Ltd.",
-            "product_description": "Products of Example Commerce",
-            "merchant_url": "https://example.com/redsys/response",
-        }
-        self.request = Request(self.parameters)
-        self.merchant_params = self.request.prepare_parameters()
-
-    def test_encode_parameters(self):
-        encoded_params = self.client.encode_parameters(self.merchant_params)
-        encoded_params_str = encoded_params.decode("UTF-8")
-        assert encoded_params_str.endswith("ZWRzeXMvcmVzcG9uc2UifQ==")
-        assert len(encoded_params_str) == 628
-
-    def test_decode_parameters(self):
-        encoded_params = self.client.encode_parameters(self.merchant_params)
-        decoded_params = self.client.decode_parameters(encoded_params)
-        assert decoded_params == self.merchant_params
-
-    def test_encrypt_3DES(self):
-        encrypted_order = self.client.encrypt_3DES(self.request.order)
-        assert len(encrypted_order) == 16
-        assert str(encrypted_order) == "b'/\\x17\\\\6\\n\\x1aY\\xf3\\xd7\\xa5\\x97\\xb9\\xb6\\xe0\\x8dH'"
-
-    def test_sign_hmac256(self):
-        encrypted_order = self.client.encrypt_3DES(self.request.order)
-        encoded_params = self.client.encode_parameters(self.merchant_params)
-        signature = self.client.sign_hmac256(encrypted_order, encoded_params)
-        assert signature == b"a2F05DwuH5aXu5vD1IdjQ+NxaR0lPsRwksW1nr2Nzuw="
-
-    def test_prepare_request(self):
-        prepared_request = self.client.prepare_request(self.parameters)
-        assert len(prepared_request.keys()) == 3
-        assert prepared_request.get("Ds_Signature") == b"a2F05DwuH5aXu5vD1IdjQ+NxaR0lPsRwksW1nr2Nzuw="
-        pass
-
-    def test_create_response_valid(self):
-        merchant_parameters = {
-            "Ds_MerchantCode": "100000001",
-            "Ds_Terminal": "1",
-            "Ds_TransactionType": "0",
-            "Ds_Currency": 978,
-            "Ds_Order": "000000000001",
-            "Ds_Amount": 1056,
-            "Ds_MerchantData": "test merchant data",
-        }
-        encoded_params = self.client.encode_parameters(merchant_parameters)
-        signature = self.client.generate_signature(self.request.order, encoded_params)
-        response = self.client.create_response(signature.decode(), encoded_params.decode())
-        assert response._parameters.get("order") == merchant_parameters.get("Ds_Order")
-
-    def test_create_response_invalid(self):
-        merchant_parameters = {
-            "Ds_MerchantCode": "100000001",
-            "Ds_Terminal": "1",
-            "Ds_TransactionType": "0",
-            "Ds_Currency": 978,
-            "Ds_Order": "000000000001",
-            "Ds_Amount": 1056,
-            "Ds_MerchantData": "test merchant data",
-        }
-        encoded_params = self.client.encode_parameters(merchant_parameters)
-        bad_signature = b"sadfe2r3q2fdssaf3"
-        with pytest.raises(ValueError, match="The provided signature is not valid"):
-            self.client.create_response(bad_signature.decode(), encoded_params.decode())