maint: improves between and length modules

tests/test__extremes.py

@@ -0,0 +1,57 @@
+"""Test Extremes."""
+# -*- coding: utf-8 -*-
+
+# standard
+from typing import Any
+
+# external
+import pytest
+
+# project
+from validators._extremes import AbsMax, AbsMin
+
+abs_max = AbsMax()
+abs_min = AbsMin()
+
+
+@pytest.mark.parametrize(
+    ("value",),
+    [(None,), ("",), (12,), (abs_min,)],
+)
+def test_abs_max_is_greater_than_every_other_value(value: Any):
+    """Test if AbsMax is greater than every other value."""
+    assert value < abs_max
+    assert abs_max > value
+
+
+def test_abs_max_is_not_greater_than_itself():
+    """Test if AbsMax is not greater than itself."""
+    assert not (abs_max > abs_max)
+
+
+def test_other_comparison_methods_for_abs_max():
+    """Test other comparison methods for AbsMax."""
+    assert abs_max <= abs_max
+    assert abs_max == abs_max
+    assert abs_max == abs_max
+
+
+@pytest.mark.parametrize(
+    ("value",),
+    [(None,), ("",), (12,), (abs_max,)],
+)
+def test_abs_min_is_smaller_than_every_other_value(value: Any):
+    """Test if AbsMin is less than every other value."""
+    assert value > abs_min
+
+
+def test_abs_min_is_not_greater_than_itself():
+    """Test if AbsMin is not less than itself."""
+    assert not (abs_min < abs_min)
+
+
+def test_other_comparison_methods_for_abs_min():
+    """Test other comparison methods for AbsMin."""
+    assert abs_min <= abs_min
+    assert abs_min == abs_min
+    assert abs_min == abs_min

tests/test_between.py

@@ -1,33 +1,59 @@
+"""Test Between."""
 # -*- coding: utf-8 -*-
+
+# standard
+from datetime import datetime
+from typing import TypeVar
+
+# external
 import pytest
 
-import validators
+# project
+from validators import between, ValidationFailure
+
 
+T = TypeVar("T", int, float, str, datetime)
 
-@pytest.mark.parametrize(('value', 'min', 'max'), [
-    (12, 11, 13),
-    (12, None, 14),
-    (12, 11, None),
-    (12, 12, 12)
-])
-def test_returns_true_on_valid_range(value, min, max):
-    assert validators.between(value, min=min, max=max)
 
+@pytest.mark.parametrize(
+    ("value", "min_val", "max_val"),
+    [(12, 11, 13), (12, None, 14), (12, 11, None), (12, 12, 12)],
+)
+def test_returns_true_on_valid_range(value: T, min_val: T, max_val: T) -> None:
+    """Test returns true on valid range."""
+    assert between(value, min_val=min_val, max_val=max_val)
 
-@pytest.mark.parametrize(('value', 'min', 'max'), [
-    (12, 13, 12),
-    (12, None, None),
-])
-def test_raises_assertion_error_for_invalid_args(value, min, max):
+
+@pytest.mark.parametrize(
+    ("value", "min_val", "max_val"),
+    [(12, 13, 12), (12, None, None)],
+)
+def test_raises_assertion_error_for_invalid_args(value: T, min_val: T, max_val: T) -> None:
+    """Test raises assertion error for invalid args."""
     with pytest.raises(AssertionError):
-        assert validators.between(value, min=min, max=max)
+        assert between(value, min_val=min_val, max_val=max_val)
+
+
+@pytest.mark.parametrize(
+    ("value", "min_val", "max_val"),
+    [
+        (12, "13.5", datetime(1970, 1, 1)),
+        ("12", 20.5, "None"),
+        (datetime(1970, 1, 1), 20, "string"),
+        (30, 40, "string"),
+    ],
+)
+def test_raises_type_error_for_invalid_args(value: T, min_val: T, max_val: T) -> None:
+    """Test raises type error for invalid args."""
+    with pytest.raises(TypeError):
+        assert between(value, min_val=min_val, max_val=max_val)
 
 
-@pytest.mark.parametrize(('value', 'min', 'max'), [
-    (12, 13, 14),
-    (12, None, 11),
-    (12, 13, None)
-])
-def test_returns_failed_validation_on_invalid_range(value, min, max):
-    result = validators.between(value, min=min, max=max)
-    assert isinstance(result, validators.ValidationFailure)
+@pytest.mark.parametrize(
+    ("value", "min_val", "max_val"),
+    [(12, 13, 14), (12, None, 11), (12, 13, None)],
+)
+def test_returns_failed_validation_on_invalid_range(value: T, min_val: T, max_val: T) -> None:
+    """Test returns failed validation on invalid range."""
+    result = between(value, min_val=min_val, max_val=max_val)
+    assert isinstance(result, ValidationFailure)

tests/test_length.py

@@ -1,37 +1,36 @@
+"""Test Length."""
 # -*- coding: utf-8 -*-
+
+# external
 import pytest
 
-import validators
+# project
+from validators import length, ValidationFailure
 
 
-@pytest.mark.parametrize(('value', 'min', 'max'), [
-    ('password', 2, 10),
-    ('password', None, 10),
-    ('password', 2, None),
-    ('password', 8, 8)
-])
-def test_returns_true_on_valid_length(value, min, max):
-    assert validators.length(value, min=min, max=max)
+@pytest.mark.parametrize(
+    ("value", "min_val", "max_val"),
+    [("password", 2, 10), ("password", 0, 10), ("password", 8, 8)],
+)
+def test_returns_true_on_valid_length(value: str, min_val: int, max_val: int):
+    """Test returns true on valid length."""
+    assert length(value, min_val=min_val, max_val=max_val)
 
 
-@pytest.mark.parametrize(('value', 'min', 'max'), [
-    ('something', 13, 12),
-    ('something', -1, None),
-    ('something', -1, None),
-    ('something', -3, -2)
-])
-def test_raises_assertion_error_for_invalid_args(value, min, max):
+@pytest.mark.parametrize(
+    ("value", "min_val", "max_val"),
+    [("something", 14, 12), ("something", -10, -20), ("something", 0, -2)],
+)
+def test_raises_assertion_error_for_invalid_args(value: str, min_val: int, max_val: int):
+    """Test raises assertion error for invalid args."""
     with pytest.raises(AssertionError):
-        assert validators.length(value, min=min, max=max)
-
-
-@pytest.mark.parametrize(('value', 'min', 'max'), [
-    ('something', 13, 14),
-    ('something', None, 6),
-    ('something', 13, None)
-])
-def test_returns_failed_validation_on_invalid_range(value, min, max):
-    assert isinstance(
-        validators.length(value, min=min, max=max),
-        validators.ValidationFailure
-    )
+        assert length(value, min_val=min_val, max_val=max_val)
+
+
+@pytest.mark.parametrize(
+    ("value", "min_val", "max_val"),
+    [("something", 13, 14), ("something", 0, 6), ("something", 14, 20)],
+)
+def test_returns_failed_validation_on_invalid_range(value: str, min_val: int, max_val: int):
+    """Test returns failed validation on invalid range."""
+    assert isinstance(length(value, min_val=min_val, max_val=max_val), ValidationFailure)

tests/test_validation_failure.py

@@ -1,25 +1,35 @@
-import validators
+"""Test validation Failure."""
+# -*- coding: utf-8 -*-
 
-obj_repr = (
-    "ValidationFailure(func=between"
-)
+# project
+from validators import between
 
 
-class TestValidationFailure(object):
-    def setup_method(self, method):
-        self.obj = validators.between(3, min=4, max=5)
+failed_obj_repr = "ValidationFailure(func=between"
+
+
+class TestValidationFailure:
+    """Test validation Failure."""
+
+    def setup_method(self):
+        """Setup Method."""
+        self.is_in_between = between(3, min_val=4, max_val=5)
 
     def test_boolean_coerce(self):
-        assert not bool(self.obj)
-        assert not self.obj
+        """Test Boolean."""
+        assert not bool(self.is_in_between)
+        assert not self.is_in_between
 
     def test_repr(self):
-        assert obj_repr in repr(self.obj)
+        """Test Repr."""
+        assert failed_obj_repr in repr(self.is_in_between)
 
-    def test_unicode(self):
-        assert obj_repr in str(self.obj)
+    def test_string(self):
+        """Test Repr."""
+        assert failed_obj_repr in str(self.is_in_between)
 
     def test_arguments_as_properties(self):
-        assert self.obj.value == 3
-        assert self.obj.min == 4
-        assert self.obj.max == 5
+        """Test argument properties."""
+        assert self.is_in_between.__dict__["value"] == 3
+        assert self.is_in_between.__dict__["min_val"] == 4
+        assert self.is_in_between.__dict__["max_val"] == 5

validators/__init__.py

@@ -1,18 +1,12 @@
+"""Validate Anything!"""
+# -*- coding: utf-8 -*-
+# from ._extremes import AbsMax, AbsMin
+
 from .between import between
 from .btc_address import btc_address
-from .card import (
-    amex,
-    card_number,
-    diners,
-    discover,
-    jcb,
-    mastercard,
-    unionpay,
-    visa
-)
+from .card import amex, card_number, diners, discover, jcb, mastercard, unionpay, visa
 from .domain import domain
 from .email import email
-from .extremes import Max, Min
 from .hashes import md5, sha1, sha224, sha256, sha512
 from .i18n import fi_business_id, fi_ssn
 from .iban import iban
@@ -25,11 +19,41 @@
 from .utils import ValidationFailure, validator
 from .uuid import uuid
 
-__all__ = ('between', 'domain', 'email', 'Max', 'Min', 'md5', 'sha1', 'sha224',
-           'sha256', 'sha512', 'fi_business_id', 'fi_ssn', 'iban', 'ipv4',
-           'ipv4_cidr', 'ipv6', 'ipv6_cidr', 'length', 'mac_address', 'slug',
-           'truthy', 'url', 'ValidationFailure', 'validator', 'uuid',
-           'card_number', 'visa', 'mastercard', 'amex', 'unionpay', 'diners',
-           'jcb', 'discover', 'btc_address')
+__all__ = (
+    "amex",
+    "between",
+    "btc_address",
+    "card_number",
+    "diners",
+    "discover",
+    "domain",
+    "email",
+    "fi_business_id",
+    "fi_ssn",
+    "iban",
+    "ipv4_cidr",
+    "ipv4",
+    "ipv6_cidr",
+    "ipv6",
+    "jcb",
+    "length",
+    "mac_address",
+    "mastercard",
+    # "AbsMax",
+    "md5",
+    # "AbsMax",
+    "sha1",
+    "sha224",
+    "sha256",
+    "sha512",
+    "slug",
+    "truthy",
+    "unionpay",
+    "url",
+    "uuid",
+    "ValidationFailure",
+    "validator",
+    "visa",
+)
 
-__version__ = '0.20.0'
+__version__ = "0.20.0"