cuenca-validations 2.0.0.dev4__tar.gz → 2.0.0.dev5__tar.gz

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cuenca_validations
-Version: 2.0.0.dev4
+Version: 2.0.0.dev5
 Summary: Cuenca common validations
 Home-page: https://github.com/cuenca-mx/cuenca-validations
 Author: Cuenca

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/cuenca_validations/errors.py

@@ -1,7 +1,6 @@
 __all__ = [
     'ApiError',
     'AuthMethodNotAllowedError',
-    'CardBinValidationError',
     'CuencaError',
     'ERROR_CODES',
     'InvalidOTPCodeError',
@@ -13,18 +12,6 @@ __all__ = [
     'WrongCredsError',
 ]
 
-from pydantic_core import PydanticCustomError
-
-
-class CardBinValidationError(PydanticCustomError):
-    code = 'payment_card_number.bin'
-    msg_template = (
-        'The card number contains a BIN (first six digits) that does not have'
-        'a known association with a Mexican bank. To add the association,'
-        'please file an issue:'
-        'https://github.com/cuenca-mx/cuenca-validations/issues'
-    )
-
 
 class CuencaError(Exception):
     """Exceptions related to ApiKeys, Login, Password, etc"""

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/cuenca_validations/types/card.py

@@ -21,6 +21,18 @@ class StrictPaymentCardNumber(BaseModel):
     def brand(self) -> PaymentCardBrand:
         return self.card_number.brand
 
+    @property
+    def last4(self) -> str:
+        return self.card_number.last4
+
+    @property
+    def masked(self) -> str:
+        return self.card_number.masked
+
+    @property
+    def bin(self) -> str:
+        return self.card_number.bin
+
     @property
     def bank_code(self) -> str:
         return CARD_BINS[self.card_number.bin]

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/cuenca_validations/types/general.py

@@ -1,5 +1,5 @@
 import json
-from typing import Generator, Optional
+from typing import Any, Optional
 
 from pydantic import BeforeValidator, Field
 from typing_extensions import Annotated
@@ -47,34 +47,19 @@ StrictPositiveFloat = Annotated[
 ]
 
 
-# Clase base para validación
-class Digits:
-    min_length: Optional[int] = None
-    max_length: Optional[int] = None
-
-    @classmethod
-    def __get_validators__(cls) -> Generator:
-        yield cls.validate_digits
-
-    @classmethod
-    def validate_digits(cls, value: str) -> str:
-        if not value.isdigit():
-            raise ValueError("Value must contain only digits.")
-        if cls.min_length is not None and len(value) < cls.min_length:
-            raise ValueError(
-                f"Value must have at least {cls.min_length} characters."
-            )
-        if cls.max_length is not None and len(value) > cls.max_length:
-            raise ValueError(
-                f"Value must have at most {cls.max_length} characters."
-            )
-        return value
-
-
-# Función para crear tipos personalizados
-def digits(min_length: Optional[int] = None, max_length: Optional[int] = None):
+def validate_only_digits(value: str) -> str:
+    if not value.isdigit():
+        raise ValueError("Value must contain only digits")
+    return value
+
+
+def digits(
+    min_length: Optional[int] = None, max_length: Optional[int] = None
+) -> Any:
     return Annotated[
-        str, Field(min_length=min_length, max_length=max_length), Digits
+        str,
+        BeforeValidator(validate_only_digits),
+        Field(min_length=min_length, max_length=max_length),
     ]
 
 

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/cuenca_validations/types/identities.py

@@ -58,6 +58,16 @@ class Rfc(StrictStr):
             raise ValueError('Not a valid RFC.')
         return cls(rfc)
 
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: Any
+    ) -> Dict[str, Any]:
+        return {
+            'type': 'str',
+            'min_length': cls.min_length,
+            'max_length': cls.max_length,
+        }
+
 
 class Address(BaseModel):
     street: Optional[str] = None

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/cuenca_validations/validators.py

@@ -4,6 +4,7 @@ from enum import Enum
 from typing import Any, Callable, List, Optional, Union
 
 from dateutil.relativedelta import relativedelta
+from pydantic import AnyUrl, HttpUrl
 
 
 def sanitize_dict(d: dict) -> dict:
@@ -26,6 +27,10 @@ def sanitize_item(
             rv = item.astimezone(dt.timezone.utc).isoformat()
         else:
             rv = item.isoformat()
+    elif isinstance(item, HttpUrl):
+        rv = str(item)
+    elif isinstance(item, AnyUrl):
+        rv = str(item)
     elif isinstance(item, list):
         rv = [
             sanitize_dict(e) if isinstance(e, dict) else sanitize_item(e)

cuenca_validations-2.0.0.dev5/cuenca_validations/version.py

@@ -0,0 +1 @@
+__version__ = '2.0.0.dev5'

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/cuenca_validations.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cuenca_validations
-Version: 2.0.0.dev4
+Version: 2.0.0.dev5
 Summary: Cuenca common validations
 Home-page: https://github.com/cuenca-mx/cuenca-validations
 Author: Cuenca

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/cuenca_validations.egg-info/SOURCES.txt

@@ -25,5 +25,6 @@ cuenca_validations/types/queries.py
 cuenca_validations/types/requests.py
 tests/__init__.py
 tests/test_card.py
+tests/test_errors.py
 tests/test_statement.py
 tests/test_types.py

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/tests/test_card.py

@@ -10,15 +10,14 @@ INVALID_BIN = '4050000000000001'
 
 def test_invalid_bin_strict_payment():
     with pytest.raises(ValidationError) as exc_info:
-        card = StrictPaymentCardNumber(card_number=INVALID_BIN)
-        print(card.card_number.bin)
+        StrictPaymentCardNumber(card_number=INVALID_BIN)
     assert 'Invalid BIN: Bank code not found.' in str(exc_info.value)
 
 
 def test_valid_bin_strict_payment():
     card = StrictPaymentCardNumber(card_number=VALID_BBVA)
-    assert card.card_number.brand == PaymentCardBrand.visa
-    assert card.card_number.bin == '477213'
-    assert card.card_number.last4 == '0003'
-    assert card.card_number.masked == '477213******0003'
+    assert card.brand == PaymentCardBrand.visa
+    assert card.bin == '477213'
+    assert card.last4 == '0003'
+    assert card.masked == '477213******0003'
     assert card.bank_code == '40012'

cuenca_validations-2.0.0.dev5/tests/test_errors.py

@@ -0,0 +1,59 @@
+import pytest
+
+from cuenca_validations.errors import (
+    ERROR_CODES,
+    ApiError,
+    AuthMethodNotAllowedError,
+    CuencaError,
+    InvalidOTPCodeError,
+    MissingAuthorizationHeaderError,
+    NoPasswordFoundError,
+    TooManyAttemptsError,
+    UserLocationError,
+    UserNotLoggedInError,
+    WrongCredsError,
+)
+
+
+def test_cuenca_error_base():
+    assert issubclass(CuencaError, Exception)
+
+
+def test_error_codes_and_status():
+    test_cases = [
+        (WrongCredsError, 101, 401),
+        (MissingAuthorizationHeaderError, 102, 401),
+        (UserNotLoggedInError, 103, 401),
+        (NoPasswordFoundError, 104, 401),
+        (AuthMethodNotAllowedError, 106, 401),
+        (TooManyAttemptsError, 107, 403),
+        (UserLocationError, 108, 401),
+        (InvalidOTPCodeError, 109, 401),
+        (ApiError, 500, 500),
+    ]
+
+    for error_class, expected_code, expected_status in test_cases:
+        assert error_class.code == expected_code
+        assert error_class.status_code == expected_status
+
+
+def test_error_messages():
+    test_message = "Mensaje de prueba"
+
+    for error_class in ERROR_CODES.values():
+        with pytest.raises(error_class) as exc_info:
+            raise error_class(test_message)
+        assert str(exc_info.value) == test_message
+
+
+def test_error_codes_mapping():
+    for error_class in ERROR_CODES.values():
+        assert ERROR_CODES[error_class.code] == error_class
+
+
+def test_api_error():
+    with pytest.raises(ApiError) as exc_info:
+        raise ApiError("Error interno")
+    assert str(exc_info.value) == "Error interno"
+    assert exc_info.value.code == 500
+    assert exc_info.value.status_code == 500

{cuenca_validations-2.0.0.dev4 → cuenca_validations-2.0.0.dev5}/tests/test_types.py

@@ -5,7 +5,7 @@ from enum import Enum
 
 import pytest
 from freezegun import freeze_time
-from pydantic import BaseModel, Field, ValidationError
+from pydantic import AnyUrl, BaseModel, HttpUrl, ValidationError
 
 from cuenca_validations.types import (
     Address,
@@ -16,6 +16,7 @@ from cuenca_validations.types import (
     SantizedDict,
     SessionRequest,
     TransactionStatus,
+    digits,
     get_state_name,
 )
 from cuenca_validations.types.enums import (
@@ -24,6 +25,10 @@ from cuenca_validations.types.enums import (
     SessionType,
     State,
 )
+from cuenca_validations.types.general import (
+    StrictPositiveFloat,
+    StrictPositiveInt,
+)
 from cuenca_validations.types.requests import (
     ApiKeyUpdateRequest,
     BankAccountValidationRequest,
@@ -127,6 +132,17 @@ def test_json_encoder(value, result):
     assert decoded['value'] == result
 
 
+def test_sanitized_dict_with_urls():
+    data = SantizedDict(
+        api_url=HttpUrl('https://api.cuenca.com/v1'),
+        ftp_url=AnyUrl('ftp://files.example.com/'),
+    )
+    assert data == {
+        'api_url': 'https://api.cuenca.com/v1',
+        'ftp_url': 'ftp://files.example.com/',
+    }
+
+
 def test_invalid_class():
     """
     For a class that doesn't have a `to_dict` method and it is not a type of
@@ -143,9 +159,7 @@ def test_invalid_class():
 
 
 class Accounts(BaseModel):
-    number: str = Field(
-        min_length=5, max_length=8, pattern=r'^\d+$'  # Only allows digits
-    )
+    number: digits(5, 8)  # type: ignore
 
 
 def test_only_digits():
@@ -156,15 +170,15 @@ def test_only_digits():
 @pytest.mark.parametrize(
     'number, error',
     [
-        ('123', 'String should have at least 5 characters'),
-        ('1234567890', 'String should have at most 8 characters'),
-        ('no_123', 'String should match pattern'),
+        ('123', 'Value should have at least 5 items after validation'),
+        ('1234567890', 'Value should have at most 8 items after validation'),
+        ('no_123', 'Value must contain only digits'),
     ],
 )
 def test_invalid_digits(number, error):
-    with pytest.raises(ValueError) as exception:
+    with pytest.raises(ValidationError) as exception:
         Accounts(number=number)
-    assert error in str(exception)
+    assert error in str(exception.value)
 
 
 def test_card_query_exp_cvv_if_number_set():
@@ -566,3 +580,59 @@ def test_user_lists_request():
     UserListsRequest(names='Pedro', first_surname='Paramo')
     with pytest.raises(ValueError):
         UserListsRequest()
+
+
+class TestFloatModel(BaseModel):
+    value: StrictPositiveFloat
+
+
+def test_strict_positive_float_valid():
+    model = TestFloatModel(value=10.5)
+    assert model.value == 10.5
+    model = TestFloatModel(value=0.000001)
+    assert model.value == 0.000001
+
+
+def test_strict_positive_float_invalid():
+    with pytest.raises(ValueError, match="Value must be greater than 0"):
+        TestFloatModel(value=0.0)
+    with pytest.raises(ValueError, match="Value must be greater than 0"):
+        TestFloatModel(value=-1.5)
+    with pytest.raises(ValueError, match="Value must be a float"):
+        TestFloatModel(value=5)
+    with pytest.raises(ValueError, match="Value must be a float"):
+        TestFloatModel(value="10.5")
+
+
+class TestIntModel(BaseModel):
+    value: StrictPositiveInt
+
+
+def test_strict_positive_int_valid():
+    model = TestIntModel(value=100)
+    assert model.value == 100
+
+    model = TestIntModel(value=1)
+    assert model.value == 1
+
+    model = TestIntModel(value=21_474_836_47)
+    assert model.value == 21_474_836_47
+
+
+def test_strict_positive_int_invalid():
+    with pytest.raises(ValueError, match="Value must be greater than 0"):
+        TestIntModel(value=0)
+
+    with pytest.raises(ValueError, match="Value must be greater than 0"):
+        TestIntModel(value=-5)
+
+    with pytest.raises(
+        ValueError, match="Value must be less than 21_474_836_47"
+    ):
+        TestIntModel(value=21_474_836_48)
+
+    with pytest.raises(ValueError, match="Value must be an integer"):
+        TestIntModel(value=5.5)
+
+    with pytest.raises(ValueError, match="Value must be an integer"):
+        TestIntModel(value="10")

cuenca_validations-2.0.0.dev4/cuenca_validations/version.py

@@ -1 +0,0 @@
-__version__ = '2.0.0.dev4'