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

python_redsys-1.2.1.dist-info/METADATA

@@ -1,140 +0,0 @@
-Metadata-Version: 2.4
-Name: python-redsys
-Version: 1.2.1
-Summary: A simple, clean and less dependant client to handle payments through Redsys.
-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.0,<4.0.0)
-Project-URL: Homepage, https://github.com/ddiazpinto/python-redsys
-Description-Content-Type: text/markdown
-
-
-[![PyPI version](https://badge.fury.io/py/python-redsys.svg)](https://badge.fury.io/py/python-redsys)
-
-# Welcome to python-redsys!
-
-A simple, clean and less dependant client to handle payments through the
-Redsys platform using one of the available methods: _redirect connection_ or (secure method).
-
-The purpose of this library is to provide a normalized interface between
-Redsys and other Python applications.
-
-**About RedirectClient**
-
-Although _redirect connection_ depends on a webserver to resolve the
-communication step, the RedirectClient provided in this library does not
-assume any kind of procedure to resolve that step; it merely prepares
-the necessary parameters to make a request and handles the corresponding
-response parameters. That's what less dependant means.
-
-## Example using _redirect connection_
-
-### 0. Install python-redsys
-
-You can add python-redsys to your project with pip:
-> pip install python-redsys
-
-Or with poetry:
-> poetry add python-redsys
-
-### 1. Instantiate the redirect client
-
-```python
-from decimal import Decimal as D, ROUND_HALF_UP
-from redsys.constants import EUR, STANDARD_PAYMENT
-from redsys.client import RedirectClient
-
-secret_key = "123456789abcdef"
-client = RedirectClient(secret_key)
-```
-
-### 2. Set up the request parameters
-
-```python
-parameters = {
-  "merchant_code": "100000001",
-  "terminal": "1",
-  "transaction_type": STANDARD_PAYMENT,
-  "currency": EUR,
-  "order": "000000001",
-  "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",
-}
-```
-
-### 3. Prepare the request
-
-This method returns a dict with the necessary post parameters that are
-needed during the communication step.
-
-```python
-args = client.prepare_request(parameters)
-```
-
-### 4. Communication step
-
-Redirect the _user-agent_ to the corresponding Redsys' endpoint using
-the post parameters given in the previous step.
-
-After the payment process is finished, Redsys will respond making a
-request to the `merchant_url` defined in step 2.
-
-### 5. Create and check the response
-
-Create the response object using the received parameters from Redsys.
-The method `create_response()` throws a `ValueError` in case the
-received signature is not equal to the calculated one using the
-given `merchant_parameters`. This normally means that the response **is
-not coming from Redsys** or that it **has been compromised**.
-
-```python
-signature = "YqFenHc2HpB273l8c995...."
-merchant_parameters = "AndvIh66VZdkC5TG3nYL5j4XfCnFFbo3VkOu9TAeTs58fxddgc..."
-response = client.create_response(signature, merchant_parameters)
-if response.is_paid:
-    # Do the corresponding actions after a successful payment
-else:
-    # Do the corresponding actions after a failed payment
-    raise Exception(response.code, response.message)
-```
-
-**Methods for checking the response:**
-
-According to the Redsys documentation:
-
-- `response.is_paid`: Returns `True` if the response code is
-  between 0 and 99 (both included).
-- `response.is_canceled`: Returns `True` if the response code
-  is 400.
-- `response.is_refunded`: Returns `True` if the response code
-  is 900.
-- `response.is_authorized`: Returns `True` if the response is
-  **paid**, **refunded** or **canceled**.
-
-Also, you can directly access the code or the message defined in Redsys
-documentation using `response.code` or `response.message`.
-
-## Contributions
-
-Please, feel free to send any contribution that maintains the _less
-dependant_ philosophy.
-

python_redsys-1.2.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-redsys/__init__.py,sha256=kRuS8epm885TJGvdrjNc9xwT70glq_h9x71_bUgT68s,138
-redsys/client.py,sha256=ervLX4FbzDfWjh_SO2SFyY9IT0PZ5aIcVZdYy4mUO7Q,3937
-redsys/constants.py,sha256=lJYgbmikxh0b9iVM4M5XFWBWVvdFY27OkcXSLluHSsQ,2497
-redsys/request.py,sha256=IEzlRi34JgDBRRyaBHtIrAZ38fADL977RdBFaeWDdbY,5304
-redsys/response.py,sha256=leDhlDlnVLGeruxlN2_3DQ-V56xAbIiFkvoqYDmz9S0,5430
-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=V8WdZ1oR4Ed5ZKmi2R-Hpgnr3AyYZy-jFH1yn2S0lA4,1220
-python_redsys-1.2.1.dist-info/METADATA,sha256=Wn6Z7SG3HtRu0PIaxBwEzsDomMFzxO_BH9M4NpFu-uA,4631
-python_redsys-1.2.1.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
-python_redsys-1.2.1.dist-info/licenses/LICENSE,sha256=Ku6mJcUOcHd2aZ4o2Jh4Tjkx1oZT-iT0VCyUNvm2IXU,1257
-python_redsys-1.2.1.dist-info/RECORD,,

python_redsys-1.2.1.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,146 +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):
-        return RESPONSE_MAP["0000"] if self.is_paid else RESPONSE_MAP[self.response]
-
-    @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())