db_fields: Add String Related forms fields options and logic + related tests

insspb · insspb · commit 7725919510ed · 2022-07-27T19:22:48.000+03:00
diff --git a/flask_mongoengine/db_fields.py b/flask_mongoengine/db_fields.py
@@ -61,6 +61,30 @@
     wtf_validators_ = None
 
 
+@wtf_required
+def _setup_strings_common_validators(options: dict, obj: fields.StringField) -> dict:
+    """
+    Extend :attr:`base_options` with common validators for string types.
+
+    :param options: dict, usually from :class:`WtfFieldMixin.wtf_generated_options`
+    :param obj: Any :class:`mongoengine.fields.StringField` subclass instance.
+    """
+    assert isinstance(obj, fields.StringField), "Improperly configured"
+    if obj.min_length or obj.max_length:
+        options["validators"].insert(
+            0,
+            wtf_validators_.Length(
+                min=obj.min_length or -1,
+                max=obj.max_length or -1,
+            ),
+        )
+
+    if obj.regex:
+        options["validators"].insert(0, wtf_validators_.Regexp(regex=obj.regex))
+
+    return options
+
+
 class WtfFieldMixin:
     """
     Extension wrapper class for mongoengine BaseField.
@@ -469,24 +493,21 @@ class EmailField(WtfFieldMixin, fields.EmailField):
     All arguments should be passed as keyword arguments, to exclude unexpected behaviour.
 
     .. versionchanged:: 2.0.0
-        Default field output changed from :class:`.NoneStringField` to
-        :class:`wtforms.fields.EmailField`
+        Default form field output changed from :class:`.NoneStringField` to
+        :class:`flask_mongoengine.wtf.fields.MongoEmailField`
     """
 
-    DEFAULT_WTF_FIELD = wtf_fields.EmailField if wtf_fields else None
+    DEFAULT_WTF_FIELD = custom_fields.MongoEmailField if custom_fields else None
 
-    def to_wtf_field(
-        self,
-        *,
-        model: Optional[Type] = None,
-        field_kwargs: Optional[dict] = None,
-    ):
-        """
-        Protection from execution of :func:`to_wtf_field` in form generation.
+    @property
+    @wtf_required
+    def wtf_generated_options(self) -> dict:
+        """Extend form validators with :class:`wtforms.validators.Email`"""
+        options = super().wtf_generated_options
+        options = _setup_strings_common_validators(options, self)
+        options["validators"].insert(0, wtf_validators_.Email())
 
-        :raises NotImplementedError: Field converter to WTForm Field not implemented.
-        """
-        raise NotImplementedError("Field converter to WTForm Field not implemented.")
+        return options
 
 
 class EmbeddedDocumentField(WtfFieldMixin, fields.EmbeddedDocumentField):
@@ -1085,22 +1106,112 @@ class StringField(WtfFieldMixin, fields.StringField):
 
     For full list of arguments and keyword arguments, look parent field docs.
     All arguments should be passed as keyword arguments, to exclude unexpected behaviour.
+
+    .. versionchanged:: 2.0.0
+        Default form field output changed from :class:`.NoneStringField` to
+        :class:`flask_mongoengine.wtf.fields.MongoTextAreaField`
     """
 
-    DEFAULT_WTF_FIELD = wtf_fields.TextAreaField if wtf_fields else None
+    DEFAULT_WTF_FIELD = custom_fields.MongoTextAreaField if custom_fields else None
 
-    def to_wtf_field(
+    def __init__(
         self,
         *,
-        model: Optional[Type] = None,
-        field_kwargs: Optional[dict] = None,
+        password: bool = False,
+        textarea: bool = False,
+        validators: Optional[Union[List, Callable]] = None,
+        filters: Optional[Union[List, Callable]] = None,
+        wtf_field_class: Optional[Type] = None,
+        wtf_filters: Optional[Union[List, Callable]] = None,
+        wtf_validators: Optional[Union[List, Callable]] = None,
+        wtf_choices_coerce: Optional[Callable] = None,
+        wtf_options: Optional[dict] = None,
+        **kwargs,
     ):
         """
-        Protection from execution of :func:`to_wtf_field` in form generation.
+        Extended :func:`__init__` method for mongoengine db field with WTForms options.
 
-        :raises NotImplementedError: Field converter to WTForm Field not implemented.
+        :param password:
+            DEPRECATED: Force to use :class:`~.MongoPasswordField` for field generation.
+            In case of :attr:`password` and :attr:`wtf_field_class` both set, then
+            :attr:`wtf_field_class` will be used.
+        :param textarea:
+            DEPRECATED: Force to use :class:`~.MongoTextAreaField` for field generation.
+            In case of :attr:`textarea` and :attr:`wtf_field_class` both set, then
+            :attr:`wtf_field_class` will be used.
+        :param filters:     DEPRECATED: wtf form field filters.
+        :param validators:  DEPRECATED: wtf form field validators.
+        :param wtf_field_class: Any subclass of :class:`wtforms.forms.core.Field` that
+            can be used for form field generation. Takes precedence over
+            :attr:`DEFAULT_WTF_FIELD`  and :attr:`DEFAULT_WTF_CHOICES_FIELD`
+        :param wtf_filters:     wtf form field filters.
+        :param wtf_validators:  wtf form field validators.
+        :param wtf_choices_coerce: Callable function to replace
+            :attr:`DEFAULT_WTF_CHOICES_COERCE` for choices fields.
+        :param wtf_options: Dictionary with WTForm Field settings.
+            Applied last, takes precedence over any generated field options.
+        :param kwargs: keyword arguments silently bypassed to normal mongoengine fields
         """
-        raise NotImplementedError("Field converter to WTForm Field not implemented.")
+        if password:
+            if textarea:
+                raise ValueError("Password field cannot use TextAreaField class.")
+
+            warnings.warn(
+                (
+                    "Passing 'password' keyword argument to field definition is "
+                    "deprecated and will be removed in version 3.0.0. "
+                    "Please use 'wtf_field_class' parameter to specify correct field "
+                    "class. If both values set, 'wtf_field_class' is used."
+                ),
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            wtf_field_class = wtf_field_class or custom_fields.MongoPasswordField
+
+        if textarea:
+            warnings.warn(
+                (
+                    "Passing 'textarea' keyword argument to field definition is "
+                    "deprecated and will be removed in version 3.0.0. "
+                    "Please use 'wtf_field_class' parameter to specify correct field "
+                    "class. If both values set, 'wtf_field_class' is used."
+                ),
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            wtf_field_class = wtf_field_class or custom_fields.MongoTextAreaField
+
+        super().__init__(
+            validators=validators,
+            filters=filters,
+            wtf_field_class=wtf_field_class,
+            wtf_filters=wtf_filters,
+            wtf_validators=wtf_validators,
+            wtf_choices_coerce=wtf_choices_coerce,
+            wtf_options=wtf_options,
+            **kwargs,
+        )
+
+    @property
+    def wtf_field_class(self) -> Type:
+        """Parent class overwrite with support of class adjustment by field size."""
+        if self._wtf_field_class:
+            return self._wtf_field_class
+        if self.max_length or self.min_length:
+            return custom_fields.MongoStringField
+        return super().wtf_field_class
+
+    @property
+    @wtf_required
+    def wtf_generated_options(self) -> dict:
+        """
+        Extend form validators with :class:`wtforms.validators.Regexp` and
+        :class:`wtforms.validators.Length`.
+        """
+        options = super().wtf_generated_options
+        options = _setup_strings_common_validators(options, self)
+
+        return options
 
 
 class URLField(WtfFieldMixin, fields.URLField):
@@ -1109,22 +1220,31 @@ class URLField(WtfFieldMixin, fields.URLField):
 
     For full list of arguments and keyword arguments, look parent field docs.
     All arguments should be passed as keyword arguments, to exclude unexpected behaviour.
+
+    .. versionchanged:: 2.0.0
+        Default form field output changed from :class:`.NoneStringField` to
+        :class:`~flask_mongoengine.wtf.fields.MongoURLField`
+
+    .. versionchanged:: 2.0.0
+        Now appends :class:`~wtforms.validators.Regexp` and use regexp provided to
+        __init__ :attr:`url_regex`, instead of using non-configurable regexp from
+        :class:`~wtforms.validators.URL`. This includes configuration conflicts, between
+        modules.
     """
 
-    DEFAULT_WTF_FIELD = custom_fields.NoneStringField if custom_fields else None
+    DEFAULT_WTF_FIELD = custom_fields.MongoURLField if custom_fields else None
 
-    def to_wtf_field(
-        self,
-        *,
-        model: Optional[Type] = None,
-        field_kwargs: Optional[dict] = None,
-    ):
-        """
-        Protection from execution of :func:`to_wtf_field` in form generation.
+    @property
+    @wtf_required
+    def wtf_generated_options(self) -> dict:
+        """Extend form validators with :class:`wtforms.validators.Regexp`"""
+        options = super().wtf_generated_options
+        options = _setup_strings_common_validators(options, self)
+        options["validators"].insert(
+            0, wtf_validators_.Regexp(regex=self.url_regex, message="Invalid URL.")
+        )
 
-        :raises NotImplementedError: Field converter to WTForm Field not implemented.
-        """
-        raise NotImplementedError("Field converter to WTForm Field not implemented.")
+        return options
 
 
 class UUIDField(WtfFieldMixin, fields.UUIDField):
diff --git a/tests/test_db_fields.py b/tests/test_db_fields.py
@@ -1,4 +1,5 @@
 """Tests for db_fields overwrite and WTForms integration."""
+import re
 from enum import Enum
 from unittest.mock import Mock
 
@@ -9,11 +10,16 @@
 from flask_mongoengine import db_fields, documents
 
 try:
+    from wtforms import fields as wtf_fields
     from wtforms import validators as wtf_validators_
 
+    from flask_mongoengine.wtf import fields as mongo_fields
+
     wtforms_not_installed = False
 except ImportError:
     wtf_validators_ = None
+    wtf_fields = None
+    mongo_fields = None
     wtforms_not_installed = True
 
 
@@ -151,7 +157,6 @@ def test__ensure_callable_or_list__raise_error_if_argument_not_callable_and_not_
             db_fields.DecimalField,
             db_fields.DictField,
             db_fields.DynamicField,
-            db_fields.EmailField,
             db_fields.EmbeddedDocumentField,
             db_fields.EmbeddedDocumentListField,
             db_fields.EnumField,
@@ -178,8 +183,6 @@ def test__ensure_callable_or_list__raise_error_if_argument_not_callable_and_not_
             db_fields.ReferenceField,
             db_fields.SequenceField,
             db_fields.SortedListField,
-            db_fields.StringField,
-            db_fields.URLField,
             db_fields.UUIDField,
         ],
     )
@@ -874,6 +877,53 @@ def test__parent__init__method_included_in_init_chain(self, db, mocker):
         mixin_init_spy.assert_called_once()
 
 
+@pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
+@pytest.mark.parametrize(
+    "StringClass",
+    [
+        db_fields.StringField,
+        db_fields.URLField,
+        db_fields.EmailField,
+    ],
+)
+class TestStringFieldCommons:
+    """
+    Ensure all string based classes call :func:`~._setup_strings_common_validators`
+    and get expected results.
+    """
+
+    @pytest.mark.parametrize(
+        ["min_", "max_", "validator_min", "validator_max"],
+        [
+            [None, 3, -1, 3],
+            [3, None, 3, -1],
+            [3, 5, 3, 5],
+        ],
+    )
+    def test__init__method__set_length_validator__if_size_given(
+        self, StringClass, min_, max_, validator_min, validator_max
+    ):
+        field = StringClass(min_length=min_, max_length=max_)
+        validator = [
+            val
+            for val in field.wtf_field_options["validators"]
+            if val.__class__ is wtf_validators_.Length
+        ][0]
+        assert validator is not None
+        assert validator.min == validator_min
+        assert validator.max == validator_max
+
+    def test__init__method__set_regex_validator__if_option(self, StringClass):
+        field = StringClass(regex="something")
+        validator = [
+            val
+            for val in field.wtf_field_options["validators"]
+            if val.__class__ is wtf_validators_.Regexp
+        ][-1]
+        assert validator is not None
+        assert validator.regex == re.compile("something")
+
+
 class TestStringField:
     """Custom test set for :class:`~flask_mongoengine.wtf.db_fields.StringField`"""
 
@@ -887,6 +937,62 @@ def test__parent__init__method_included_in_init_chain(self, db, mocker):
         field_init_spy.assert_called_once()
         mixin_init_spy.assert_called_once()
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
+    def test__init__method_report_warning__if_password_keyword_setting_set(
+        self, recwarn
+    ):
+        field = db_fields.StringField(password=True)
+        assert str(recwarn.list[0].message) == (
+            "Passing 'password' keyword argument to field definition is "
+            "deprecated and will be removed in version 3.0.0. "
+            "Please use 'wtf_field_class' parameter to specify correct field "
+            "class. If both values set, 'wtf_field_class' is used."
+        )
+        assert issubclass(field.wtf_field_class, wtf_fields.PasswordField)
+
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
+    def test__init__method_report_warning__if_textarea_keyword_setting_set(
+        self, recwarn
+    ):
+        field = db_fields.StringField(textarea=True)
+        assert str(recwarn.list[0].message) == (
+            "Passing 'textarea' keyword argument to field definition is "
+            "deprecated and will be removed in version 3.0.0. "
+            "Please use 'wtf_field_class' parameter to specify correct field "
+            "class. If both values set, 'wtf_field_class' is used."
+        )
+        assert issubclass(field.wtf_field_class, wtf_fields.TextAreaField)
+
+    def test__init__method_raise_error__if_password_and_keyword_setting_both_set(self):
+        with pytest.raises(ValueError) as error:
+            db_fields.StringField(textarea=True, password=True)
+
+        assert str(error.value) == "Password field cannot use TextAreaField class."
+
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
+    def test__init__method__set_textarea__in__wtf_field_class__even_if_size_given(self):
+        field = db_fields.StringField(textarea=True, min_length=3)
+        assert field.wtf_field_class is mongo_fields.MongoTextAreaField
+
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
+    @pytest.mark.parametrize(
+        ["min_", "max_"],
+        [
+            [None, 3],
+            [3, None],
+            [3, 5],
+        ],
+    )
+    def test__init__method__set_string_field_class__if_size_given(self, min_, max_):
+        field = db_fields.StringField(min_length=min_, max_length=max_)
+        validator = [
+            val
+            for val in field.wtf_field_options["validators"]
+            if val.__class__ is wtf_validators_.Length
+        ]
+        assert field.wtf_field_class is mongo_fields.MongoStringField
+        assert validator is not None
+
 
 class TestURLField:
     """Custom test set for :class:`~flask_mongoengine.wtf.db_fields.URLField`"""
