Added tests for serializer module

tests/db/orm/django/test_serializers.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from django.core.validators import BaseValidator
+from django.core.exceptions import ValidationError as DjangoValidationError
+
+from aiorest_ws.db.orm.abstract import empty
+from aiorest_ws.db.orm.exceptions import ValidationError
+from aiorest_ws.db.orm.serializers import Serializer
+from aiorest_ws.db.orm.django import fields
+from aiorest_ws.db.orm.django.serializers import ListSerializer, \
+    get_validation_error_detail
+
+
+class TestGetValidationErrorDetailFunction(unittest.TestCase):
+
+    def test_function_raises_assert_error_for_invalid_exception_type(self):
+        exc = ValueError()
+        self.assertRaises(AssertionError, get_validation_error_detail, exc)
+
+    def test_function_returns_dict_for_django_validation_error(self):
+        message = '@ must be in email address'
+        exc = DjangoValidationError(message)
+        detail = get_validation_error_detail(exc)
+
+        self.assertIsInstance(detail, dict)
+        self.assertIn('non_field_errors', detail.keys())
+        self.assertEqual(detail['non_field_errors'][0], message)
+
+    def test_function_returns_dict_for_exception_with_message_as_dict(self):
+        message = {'email': '@ must be in email address'}
+        exc = ValidationError(message)
+        detail = get_validation_error_detail(exc)
+
+        self.assertIsInstance(detail, dict)
+        self.assertIn('email', detail.keys())
+        self.assertEqual(detail['email'][0], message['email'])
+
+    def test_function_returns_dict_for_exception_with_message_as_list(self):
+        message = ['@ must be in email address', ]
+        exc = ValidationError(message)
+        detail = get_validation_error_detail(exc)
+
+        self.assertIsInstance(detail, dict)
+        self.assertIn('non_field_errors', detail.keys())
+        self.assertIsInstance(detail['non_field_errors'], list)
+        self.assertEqual(len(detail['non_field_errors']), 1)
+        self.assertEqual(detail['non_field_errors'], message)
+
+    def test_function_returns_dict_for_exception_with_message_as_string(self):
+        message = '@ must be in email address'
+        exc = ValidationError('expected message')
+        exc.detail = message  # someone patched object
+        detail = get_validation_error_detail(exc)
+
+        self.assertIsInstance(detail, dict)
+        self.assertIn('non_field_errors', detail.keys())
+        self.assertIsInstance(detail['non_field_errors'], list)
+        self.assertEqual(len(detail['non_field_errors']), 1)
+        self.assertEqual(detail['non_field_errors'][0], message)
+
+
+class TestListSerializer(unittest.TestCase):
+
+    class FakeSerializer(Serializer):
+        default_list_serializer = ListSerializer
+        pk = fields.IntegerField()
+
+        def run_validation(self, data=empty):
+            return self.to_internal_value(data)
+
+    def test_run_validation_returns_value(self):
+        instance = self.FakeSerializer(many=True)
+        self.assertEqual(
+            instance.run_validation([{'pk': 1}, ]),
+            [{'pk': 1}, ]
+        )
+
+    def test_run_validation_returns_value_for_empty_value(self):
+        instance = self.FakeSerializer(many=True, allow_null=True)
+        self.assertEqual(instance.run_validation(None), None)
+
+    def test_run_validation_raises_validation_error(self):
+
+        class NegativePkValidator(BaseValidator):
+
+            def __call__(self, data):
+                for obj in data:
+                    if obj['pk'] < 0:
+                        raise ValidationError("PKs can't be negative.")
+
+        class CustomListSerializer(ListSerializer):
+            validators = [NegativePkValidator(10), ]
+
+        class InvalidFakeSerializer(self.FakeSerializer):
+
+            class Meta:
+                list_serializer_class = CustomListSerializer
+
+        instance = InvalidFakeSerializer(many=True)
+        self.assertRaises(
+            ValidationError,
+            instance.run_validation,
+            [{'pk': -1}, ]
+        )
+
+    def test_run_validation_raises_assertion_error_for_none_value(self):
+
+        class CustomListSerializer(ListSerializer):
+            def validate(self, data):
+                return None  # suppose, that something happens wrong
+
+        class InvalidFakeSerializer(self.FakeSerializer):
+            class Meta:
+                list_serializer_class = CustomListSerializer
+
+        instance = InvalidFakeSerializer(many=True)
+        self.assertRaises(
+            AssertionError,
+            instance.run_validation,
+            [{'pk': 1}, ]
+        )