cleanup + typing

Author: systemallica

redsys/client.py

@@ -4,7 +4,8 @@
 import hmac
 import json
 import re
-from abc import ABCMeta, abstractmethod
+from abc import ABC, abstractmethod
+from typing import Any, Dict
 
 from Crypto.Cipher import DES3
 
@@ -18,10 +19,13 @@
 DEFAULT_SIGNATURE_VERSION = "HMAC_SHA256_V1"
 
 
-class Client(object):
-    __metaclass__ = ABCMeta
+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=None):
+    def __init__(self, secret_key: str = None):
         self.secret_key = secret_key
 
     @abstractmethod
@@ -34,15 +38,28 @@ def create_response(
     def prepare_request(self, request):
         raise NotImplementedError
 
-    def encode_parameters(self, parameters):
+    @staticmethod
+    def encode_parameters(parameters: Dict[str, Any]) -> bytes:
         """Encodes the merchant parameters in base64"""
         return base64.b64encode(json.dumps(parameters).encode())
 
-    def decode_parameters(self, parameters):
+    @staticmethod
+    def decode_parameters(parameters: bytes) -> Dict[str, Any]:
         """Decodes the merchant parameters from base64"""
         return json.loads(base64.b64decode(parameters).decode())
 
-    def encrypt_3DES(self, order):
+    @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"
@@ -52,22 +69,12 @@ def encrypt_3DES(self, order):
         # therefore we left-justify adding ceros
         return cipher.encrypt(order.encode().ljust(16, b"\0"))
 
-    def sign_hmac256(self, encrypted_order, merchant_parameters):
-        """
-        Generates the encrypted signature using the encrypted order
-        and merchant parameters
-        """
-        signature = hmac.new(
-            encrypted_order, merchant_parameters, hashlib.sha256
-        ).digest()
-        return base64.b64encode(signature)
-
-    def generate_signature(self, order, merchant_parameters):
+    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):
+    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)
@@ -81,14 +88,14 @@ def prepare_request(self, parameters):
 
     def create_response(
         self,
-        signature,
-        merchant_parameters,
-    ):
+        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.
+        Both the `signature` and `merchant parameters` are plain strings, not bytes.
         """
         decoded_parameters = self.decode_parameters(merchant_parameters)
         response = Response(decoded_parameters)

redsys/response.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 from decimal import Decimal
+from typing import Any, Dict
 
 RESPONSE = "Ds_Response"
 DATE = "Ds_Date"
@@ -85,14 +86,14 @@
 }
 
 
-class Response(object):
+class Response:
     """
     Defines a response
     """
 
     _parameters = {}
 
-    def __init__(self, parameters):
+    def __init__(self, parameters: Dict[str, Any]):
         MERCHANT_PARAMETERS_MAP_REVERSE = {
             value: key for key, value in MERCHANT_PARAMETERS_MAP.items()
         }
@@ -104,37 +105,34 @@ def __init__(self, parameters):
                 clean(value) if clean else value
             )
 
-    def __getattr__(self, item):
+    def __getattr__(self, item: str) -> Any:
         if item in MERCHANT_PARAMETERS_MAP:
             return self._parameters[item]
 
-    def __setattr__(self, key, value):
+    def __setattr__(self, key: str, value: Any):
         if key in MERCHANT_PARAMETERS_MAP:
             self._parameters[key] = value
 
     def is_authorized(self):
-        return (
-            (0 <= self.response_code <= 99)
-            or self.response_code == 900
-            or self.response_code == 400
-        )
+        return (0 <= self.code <= 99) or self.code == 900 or self.code == 400
 
     def is_paid(self):
-        return 0 <= self.response_code <= 99
+        return 0 <= self.code <= 99
 
     def is_refunded(self):
-        return self.response_code == 900
+        return self.code == 900
 
     def is_canceled(self):
-        return self.response_code == 400
+        return self.code == 400
 
     @property
-    def response_code(self):
+    def code(self):
         return int(self.response)
 
     @property
-    def response_message(self):
+    def message(self):
         return RESPONSE_MAP["0000"] if self.is_paid() else RESPONSE_MAP[self.response]
 
-    def clean_amount(self, value):
+    @staticmethod
+    def clean_amount(value):
         return Decimal("%s.%s" % (str(value)[:-2], str(value)[-2:]))

redsys/tests/test_client.py

@@ -3,17 +3,17 @@
 
 import pytest
 
-from redsys.client import Client, RedirectClient
+from redsys.client import RedirectClient
 from redsys.constants import EUR, STANDARD_PAYMENT
 from redsys.request import Request
 
 
-class TestClient:
+class TestRedirectClient:
     @pytest.fixture(autouse=True)
     def set_up(self):
         secret_key = "sq7HjrUOBfKmC576ILgskD5srU870gJ7"
-        self.client = Client(secret_key)
-        parameters = {
+        self.client = RedirectClient(secret_key)
+        self.parameters = {
             "merchant_code": "100000001",
             "terminal": "1",
             "transaction_type": STANDARD_PAYMENT,
@@ -26,7 +26,7 @@ def set_up(self):
             "product_description": "Products of Example Commerce",
             "merchant_url": "https://example.com/redsys/response",
         }
-        self.request = Request(parameters)
+        self.request = Request(self.parameters)
         self.merchant_params = self.request.prepare_parameters()
 
     def test_encode_parameters(self):
@@ -54,27 +54,6 @@ def test_sign_hmac256(self):
         signature = self.client.sign_hmac256(encrypted_order, encoded_params)
         assert signature == b"eEW4YN7/kkNHRO0/HhXy9TppzHwF38+eZApKAagDI9A="
 
-
-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": "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",
-        }
-        self.request = Request(self.parameters)
-
     def test_prepare_request(self):
         prepared_request = self.client.prepare_request(self.parameters)
         assert len(prepared_request.keys()) == 3