Merge pull request #97 from binary-butterfly/email-validator-max-length

EmailValidator: Add max_length parameter

Author: binaryDiv

docs/03-basic-validators.md

@@ -228,24 +228,31 @@ validator_empty_string.validate('') # will return "" (empty string)
 
 The `EmailValidator` validates email addresses as strings and returns them unmodified.
 
-Please note that this validator is a bit opinionated and simplified in that it does **not** allow every email address that technically
-is valid according to the RFCs. For example, it does neither allow internationalized email addresses (although this might be changed
-in the future), nor oddities like quoted strings as local part or comments, because most mail software does not support those anyway
-and/or might break with those adresses.
+Please note that this validator is a bit opinionated and simplified in that it does **not** allow every email address
+that technically is valid according to the RFCs. For example, it does neither allow internationalized email addresses
+(although this might be changed in the future), nor oddities like quoted strings as local part or comments, because most
+mail software does not support those anyway and/or might break with those adresses.
 
-Currently this validator has parameter `allow_empty`. To allow empty strings as input, you can set the `allow_empty` parameter to `True` (defaults to `False`).
+By default, the validator does not accept empty strings as input. To allow them, set the parameter `allow_empty=True`.
+
+Also, the default maximum string length is set to 256 characters (which would be a really long, but still valid email
+address), which can be changed using the `max_length` parameter.
 
 **Example:**
 
 ```python
 from validataclass.validators import EmailValidator
 
+# Default email validator
 validator = EmailValidator()
 validator.validate("[email protected]")  # will return "[email protected]"
-validator.validate("banana")           # will return InvalidEmailError(reason='Invalid email address format.')
+validator.validate("banana")           # will raise InvalidEmailError(reason='Invalid email address format.')
+validator.validate("")                 # will raise StringTooShortError(min_length=1, max_length=256)
 
-validator_empty_string = EmailValidator(allow_empty=True)
-validator_empty_string.validate('')    # will return "" (empty string)
+# Allow empty strings as input
+validator = EmailValidator(allow_empty=True)
+validator.validate("[email protected]")  # will return "[email protected]"
+validator.validate("")                 # will return "" (empty string)
 ```
 
 

src/validataclass/validators/email_validator.py

@@ -23,12 +23,14 @@ class EmailValidator(StringValidator):
     """
     Validator for email addresses.
 
-    Please note that this validator is a bit opinionated and simplified in that it does *not* allow every email address that technically
-    is valid according to the RFCs. For example, it does neither allow internationalized email addresses (although this might be changed
-    in the future), nor oddities like quoted strings as local part or comments, because most mail software does not support those anyway
-    and/or might break with those addresses.
+    Please note that this validator is a bit opinionated and simplified in that it does *not* allow every email address
+    that technically is valid according to the RFCs. For example, it does neither allow internationalized email
+    addresses (although this might be changed in the future), nor oddities like quoted strings as local part or comments,
+    because most mail software does not support those anyway and/or might break with those addresses.
 
-    Set the parameter `allow_empty=True` to allow empty strings ('').
+    Set the parameter `allow_empty=True` to allow empty strings as input.
+
+    By default, the maximum string length is set to 256 characters. This can be changed with the `max_length` parameter.
 
     Example:
 
@@ -53,21 +55,26 @@ class EmailValidator(StringValidator):
     # Whether to accept empty strings
     allow_empty: bool = False
 
-    def __init__(self, *,
-                 allow_empty: bool = False,):
+    def __init__(
+        self,
+        *,
+        allow_empty: bool = False,
+        max_length: int = 256,
+    ):
         """
         Create a `EmailValidator`.
 
         Parameters:
             allow_empty: Boolean, if True, empty strings are accepted as valid email addresses (default: False)
+            max_length: Integer, maximum length of input string (default: 256)
         """
         self.allow_empty = allow_empty
 
         # Allow string with length 0 if `allow_empty=True`
         min_length = 0 if allow_empty else 1
 
         # Initialize StringValidator with some length requirements
-        super().__init__(min_length=min_length, max_length=256)
+        super().__init__(min_length=min_length, max_length=max_length)
 
     def validate(self, input_data: Any, **kwargs) -> str:
         """

tests/validators/email_validator_test.py

@@ -34,7 +34,7 @@ def test_invalid_wrong_type():
 
     @staticmethod
     def test_invalid_empty_string():
-        """ Check that EmailValidator raises exceptions for empty strings. """
+        """ Check that EmailValidator raises exceptions for empty strings by default. """
         validator = EmailValidator()
         with pytest.raises(StringInvalidLengthError) as exception_info:
             validator.validate('')
@@ -56,26 +56,46 @@ def test_invalid_empty_string():
         ]
     )
     def test_allow_empty_valid(input_string):
-        """ Check that EmailValidator returns empty string if boolean parameter allow_empty=True. """
+        """ Test that EmailValidator returns empty string if boolean parameter allow_empty=True. """
         validator = EmailValidator(allow_empty=True)
         assert validator.validate(input_string) == input_string
 
+    # Test maximum string length
+
     @staticmethod
-    def test_invalid_string_too_long():
-        """ Check that EmailValidator raises exceptions for strings that are too long. """
+    @pytest.mark.parametrize('allow_empty', [True, False])
+    def test_invalid_string_too_long(allow_empty):
+        """ Test that EmailValidator raises exceptions for strings that are too long. """
         # Construct an email address that is technically valid but too long
         input_string = ('a' * 64) + '@' + ('very-very-very-very-very-very-very-long-domain.' * 4)
         input_string += 'b' * (257 - len(input_string))
 
-        validator = EmailValidator()
+        validator = EmailValidator(allow_empty=allow_empty)
         with pytest.raises(StringInvalidLengthError) as exception_info:
             validator.validate(input_string)
         assert exception_info.value.to_dict() == {
             'code': 'string_too_long',
-            'min_length': 1,
+            'min_length': 0 if allow_empty else 1,
             'max_length': 256,
         }
 
+    @staticmethod
+    def test_max_length_parameter():
+        """ Test EmailValidator with a custom value for max_length. """
+        validator = EmailValidator(max_length=16)
+
+        # Valid input (16 characters)
+        assert validator.validate('[email protected]')
+
+        # Invalid input (17 characters)
+        with pytest.raises(StringInvalidLengthError) as exception_info:
+            validator.validate('[email protected]')
+        assert exception_info.value.to_dict() == {
+            'code': 'string_too_long',
+            'min_length': 1,
+            'max_length': 16,
+        }
+
     # Tests for regex validation of email address format
 
     @staticmethod