Merge pull request #533 from PROCOLLAB-github/feature/project-mospolytech-data

Доработана валидация данных дополнительных полей программ

Author: Toksi86

partner_programs/tests.py

@@ -0,0 +1,213 @@
+from django.test import TestCase
+from django.utils import timezone
+
+from partner_programs.models import PartnerProgram, PartnerProgramField
+from projects.serializers import PartnerProgramFieldValueUpdateSerializer
+
+
+class PartnerProgramFieldValueUpdateSerializerInvalidTests(TestCase):
+    def setUp(self):
+        now = timezone.now()
+        self.partner_program = PartnerProgram.objects.create(
+            name="Тестовая программа",
+            tag="test_tag",
+            description="Описание тестовой программы",
+            city="Москва",
+            image_address="https://example.com/image.png",
+            cover_image_address="https://example.com/cover.png",
+            advertisement_image_address="https://example.com/advertisement.png",
+            presentation_address="https://example.com/presentation.pdf",
+            data_schema={},
+            draft=True,
+            projects_availability="all_users",
+            datetime_registration_ends=now + timezone.timedelta(days=30),
+            datetime_started=now,
+            datetime_finished=now + timezone.timedelta(days=60),
+        )
+
+    def make_field(self, field_type, is_required, options=None):
+        return PartnerProgramField.objects.create(
+            partner_program=self.partner_program,
+            name="test_field",
+            label="Test Field",
+            field_type=field_type,
+            is_required=is_required,
+            options="|".join(options) if options else "",
+        )
+
+    def test_required_text_field_empty(self):
+        field = self.make_field("text", is_required=True)
+        data = {"field_id": field.id, "value_text": ""}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn(
+            "Поле должно содержать текстовое значение.", str(serializer.errors)
+        )
+
+    def test_required_textarea_field_null(self):
+        field = self.make_field("textarea", is_required=True)
+        data = {"field_id": field.id, "value_text": None}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn(
+            "Поле должно содержать текстовое значение.", str(serializer.errors)
+        )
+
+    def test_checkbox_invalid_string(self):
+        field = self.make_field("checkbox", is_required=True)
+        data = {"field_id": field.id, "value_text": "maybe"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("ожидается 'true' или 'false'", str(serializer.errors).lower())
+
+    def test_checkbox_invalid_type(self):
+        field = self.make_field("checkbox", is_required=True)
+        data = {"field_id": field.id, "value_text": 1}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("ожидается 'true' или 'false'", str(serializer.errors).lower())
+
+    def test_select_invalid_choice(self):
+        field = self.make_field("select", is_required=True, options=["арбуз", "ананас"])
+        data = {"field_id": field.id, "value_text": "яблоко"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn(
+            "Недопустимое значение для поля типа 'select'", str(serializer.errors)
+        )
+
+    def test_select_required_empty(self):
+        field = self.make_field("select", is_required=True, options=["арбуз", "ананас"])
+        data = {"field_id": field.id, "value_text": ""}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn(
+            "Значение обязательно для поля типа 'select'", str(serializer.errors)
+        )
+
+    def test_radio_invalid_type(self):
+        field = self.make_field("radio", is_required=True, options=["арбуз", "ананас"])
+        data = {"field_id": field.id, "value_text": ["арбуз"]}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("Not a valid string.", str(serializer.errors))
+
+    def test_radio_invalid_value(self):
+        field = self.make_field("radio", is_required=True, options=["арбуз", "ананас"])
+        data = {"field_id": field.id, "value_text": "груша"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn(
+            "Недопустимое значение для поля типа 'radio'", str(serializer.errors)
+        )
+
+    def test_file_invalid_type(self):
+        field = self.make_field("file", is_required=True)
+        data = {"field_id": field.id, "value_text": 123}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn(
+            "Ожидается корректная ссылка (URL) на файл.", str(serializer.errors)
+        )
+
+    def test_file_empty_required(self):
+        field = self.make_field("file", is_required=True)
+        data = {"field_id": field.id, "value_text": ""}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("Файл обязателен для этого поля.", str(serializer.errors))
+
+
+class PartnerProgramFieldValueUpdateSerializerValidTests(TestCase):
+    def setUp(self):
+        now = timezone.now()
+        self.partner_program = PartnerProgram.objects.create(
+            name="Тестовая программа",
+            tag="test_tag",
+            description="Описание тестовой программы",
+            city="Москва",
+            image_address="https://example.com/image.png",
+            cover_image_address="https://example.com/cover.png",
+            advertisement_image_address="https://example.com/advertisement.png",
+            presentation_address="https://example.com/presentation.pdf",
+            data_schema={},
+            draft=True,
+            projects_availability="all_users",
+            datetime_registration_ends=now + timezone.timedelta(days=30),
+            datetime_started=now,
+            datetime_finished=now + timezone.timedelta(days=60),
+        )
+
+    def make_field(self, field_type, is_required, options=None):
+        return PartnerProgramField.objects.create(
+            partner_program=self.partner_program,
+            name="test_field",
+            label="Test Field",
+            field_type=field_type,
+            is_required=is_required,
+            options="|".join(options) if options else "",
+        )
+
+    def test_optional_text_field_valid(self):
+        field = self.make_field("text", is_required=False)
+        data = {"field_id": field.id, "value_text": "some value"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_required_text_field_valid(self):
+        field = self.make_field("text", is_required=True)
+        data = {"field_id": field.id, "value_text": "not empty"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_optional_textarea_valid(self):
+        field = self.make_field("textarea", is_required=False)
+        data = {"field_id": field.id, "value_text": "optional long text"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_required_textarea_valid(self):
+        field = self.make_field("textarea", is_required=True)
+        data = {"field_id": field.id, "value_text": "required long text"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_checkbox_true_valid(self):
+        field = self.make_field("checkbox", is_required=True)
+        data = {"field_id": field.id, "value_text": "true"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_checkbox_false_valid(self):
+        field = self.make_field("checkbox", is_required=False)
+        data = {"field_id": field.id, "value_text": "false"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_select_valid(self):
+        field = self.make_field("select", is_required=True, options=["арбуз", "ананас"])
+        data = {"field_id": field.id, "value_text": "ананас"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_radio_valid(self):
+        field = self.make_field(
+            "radio", is_required=True, options=["арбуз", "апельсин"]
+        )
+        data = {"field_id": field.id, "value_text": "апельсин"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_optional_select_empty_valid(self):
+        field = self.make_field(
+            "select", is_required=False, options=["арбуз", "апельсин"]
+        )
+        data = {"field_id": field.id, "value_text": ""}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+
+    def test_file_valid_url(self):
+        field = self.make_field("file", is_required=True)
+        data = {"field_id": field.id, "value_text": "https://example.com/file.pdf"}
+        serializer = PartnerProgramFieldValueUpdateSerializer(data=data)
+        self.assertTrue(serializer.is_valid())

projects/serializers.py

@@ -1,3 +1,5 @@
+from urllib.parse import urlparse
+
 from django.contrib.auth import get_user_model
 from django.core.cache import cache
 from rest_framework import serializers
@@ -410,40 +412,120 @@ class PartnerProgramFieldValueUpdateSerializer(serializers.Serializer):
         required=False,
         allow_blank=True,
         allow_null=True,
-        help_text="Укажите значение для текстового поля.",
+        help_text="Укажите значение для поля.",
     )
 
     def validate(self, attrs):
         field = attrs.get("field")
         value_text = attrs.get("value_text")
 
-        is_required = field.is_required
+        validator = self._get_validator(field)
+        validator(field, value_text, attrs)
+
+        return attrs
+
+    def _get_validator(self, field):
+        validators = {
+            "text": self._validate_text,
+            "textarea": self._validate_text,
+            "checkbox": self._validate_checkbox,
+            "select": self._validate_select,
+            "radio": self._validate_radio,
+            "file": self._validate_file,
+        }
+        try:
+            return validators[field.field_type]
+        except KeyError:
+            raise serializers.ValidationError(
+                f"Тип поля '{field.field_type}' не поддерживается."
+            )
 
-        if field.field_type == "text" or field.field_type == "text":
-            if is_required and (value_text is None or value_text == "textarea"):
+    def _validate_text(self, field, value, attrs):
+        if field.is_required:
+            if value is None or str(value).strip() == "":
                 raise serializers.ValidationError(
                     "Поле должно содержать текстовое значение."
                 )
-        elif field.field_type == "checkbox":
-            if is_required and value_text in (None, ""):
+        else:
+            if value is not None and not isinstance(value, str):
                 raise serializers.ValidationError(
-                    "Значение обязательно для поля типа 'checkbox'."
+                    "Ожидается строка для текстового поля."
                 )
-            if value_text is not None:
-                if isinstance(value_text, bool):
-                    attrs["value_text"] = "true" if value_text else "false"
-                elif isinstance(value_text, str):
-                    if value_text.lower() not in ("true", "false"):
-                        raise serializers.ValidationError(
-                            "Для поля типа 'checkbox' ожидается 'true' или 'false'."
-                        )
-                    attrs["value_text"] = value_text.lower()
-                else:
+
+    def _validate_checkbox(self, field, value, attrs):
+        if field.is_required and value in (None, ""):
+            raise serializers.ValidationError(
+                "Значение обязательно для поля типа 'checkbox'."
+            )
+
+        if value is not None:
+            if isinstance(value, bool):
+                attrs["value_text"] = "true" if value else "false"
+            elif isinstance(value, str):
+                normalized = value.strip().lower()
+                if normalized not in ("true", "false"):
                     raise serializers.ValidationError(
-                        "Неверный тип значения для поля 'checkbox'."
+                        "Для поля типа 'checkbox' ожидается 'true' или 'false'."
                     )
-        else:
+                attrs["value_text"] = normalized
+            else:
+                raise serializers.ValidationError(
+                    "Неверный тип значения для поля 'checkbox'."
+                )
+
+    def _validate_select(self, field, value, attrs):
+        self._validate_choice_field(field, value, "select")
+
+    def _validate_radio(self, field, value, attrs):
+        self._validate_choice_field(field, value, "radio")
+
+    def _validate_choice_field(self, field, value, field_type):
+        options = field.get_options_list()
+
+        if not options:
             raise serializers.ValidationError(
-                f"Тип поля '{field.field_type}' не поддерживается."
+                f"Для поля типа '{field_type}' не заданы допустимые значения."
             )
-        return attrs
+
+        if field.is_required:
+            if value is None or value == "":
+                raise serializers.ValidationError(
+                    f"Значение обязательно для поля типа '{field_type}'."
+                )
+        else:
+            if value is None or value == "":
+                return  # Пустое значение для необязательного поля допустимо
+
+        if value is not None:
+            if not isinstance(value, str):
+                raise serializers.ValidationError(
+                    f"Ожидается строковое значение для поля типа '{field_type}'."
+                )
+            if value not in options:
+                raise serializers.ValidationError(
+                    f"Недопустимое значение для поля типа '{field_type}'. "
+                    f"Ожидается одно из: {options}."
+                )
+
+    def _validate_file(self, field, value, attrs):
+        if field.is_required:
+            if value is None or value == "":
+                raise serializers.ValidationError("Файл обязателен для этого поля.")
+
+        if value is not None:
+            if not isinstance(value, str):
+                raise serializers.ValidationError(
+                    "Ожидается строковое значение для поля 'file'."
+                )
+
+            if not self._is_valid_url(value):
+                raise serializers.ValidationError(
+                    "Ожидается корректная ссылка (URL) на файл."
+                )
+
+    def _is_valid_url(self, url: str) -> bool:
+        try:
+            parsed = urlparse(url)
+            return parsed.scheme in ("http", "https") and bool(parsed.netloc)
+        except Exception:
+            return False