simo 1.7.20__py3-none-any.whl → 2.0.1__py3-none-any.whl

simo/core/drf_braces/tests/forms/test_fields.py

@@ -0,0 +1,46 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import unittest
+from datetime import datetime
+
+import pytz
+from dateutil.tz import tzoffset
+from django import forms
+from rest_framework import ISO_8601
+
+from ...forms.fields import ISO8601DateTimeField
+
+
+class TestISO8601DateTimeField(unittest.TestCase):
+    def test_to_python_empty(self):
+        field = ISO8601DateTimeField(required=False)
+
+        self.assertIsNone(field.clean(''))
+
+    def test_to_python_not_iso8601(self):
+        field = ISO8601DateTimeField()
+
+        self.assertEqual(field.clean('2015-01-01 16:30'), datetime(2015, 1, 1, 16, 30))
+        with self.assertRaises(forms.ValidationError):
+            field.clean('2015-01-01T16:30')
+
+    def test_to_python_iso8601(self):
+        field = ISO8601DateTimeField(input_formats=[ISO_8601])
+
+        self.assertEqual(
+            field.clean('2015-01-01 16:30'),
+            datetime(2015, 1, 1, 16, 30)
+        )
+        self.assertEqual(
+            field.clean('2015-01-01T16:30'),
+            datetime(2015, 1, 1, 16, 30)
+        )
+        self.assertEqual(
+            field.clean('2015-01-01T16:30+00:00'),
+            datetime(2015, 1, 1, 16, 30).replace(tzinfo=pytz.UTC)
+        )
+        self.assertEqual(
+            field.clean('2015-01-01T16:30+04:00'),
+            datetime(2015, 1, 1, 16, 30).replace(tzinfo=tzoffset(None, 4 * 60 * 60))
+        )
+        with self.assertRaises(forms.ValidationError):
+            field.clean('2015-01-01T16:30+A')

simo/core/drf_braces/tests/forms/test_serializer_form.py

@@ -0,0 +1,256 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import unittest
+from datetime import datetime
+
+import mock
+import six
+from django import forms
+from rest_framework import serializers
+
+from ...forms.serializer_form import (
+    SERIALIZER_FORM_FIELD_MAPPING,
+    SerializerForm,
+    SerializerFormBase,
+    SerializerFormMeta,
+    SerializerFormOptions,
+    form_from_serializer,
+)
+
+
+TESTING_MODULE = 'drf_braces.forms.serializer_form'
+
+
+class TestSerializer(serializers.Serializer):
+    foo = serializers.CharField(read_only=True)
+    bar = serializers.IntegerField(min_value=0)
+    exclude = serializers.DateTimeField()
+
+    def validate_bar(self, value):
+        if value >= 1000:
+            raise serializers.ValidationError('Serializer failure')
+        return value
+
+
+class TestForm(SerializerForm):
+    class Meta(object):
+        serializer = TestSerializer
+        fields = ['bar', 'foo']
+        exclude = ['exclude']
+
+
+class TestSerializerFormOptions(unittest.TestCase):
+    def test_init(self):
+        _options = mock.Mock(serializer=serializers.Serializer)
+
+        options = SerializerFormOptions(_options)
+
+        self.assertEqual(options.serializer, _options.serializer)
+        self.assertEqual(options.fields, _options.fields)
+        self.assertEqual(options.exclude, _options.exclude)
+        self.assertEqual(options.field_mapping, _options.field_mapping)
+
+    def test_init_no_serializer(self):
+        with self.assertRaises(AssertionError):
+            SerializerFormOptions(None)
+
+    def test_init_not_drf_serializer(self):
+        with self.assertRaises(AssertionError):
+            SerializerFormOptions(mock.Mock(serializer=int))
+
+
+class TestSerializerFormMeta(unittest.TestCase):
+    @mock.patch.dict(SERIALIZER_FORM_FIELD_MAPPING, {'base': 'mapping'}, clear=True)
+    def test_get_field_mapping(self):
+        class Base1B(object):
+            class _meta(object):
+                field_mapping = {
+                    'hello': 'mars',
+                    'hi': 'there',
+                    'foo': 'bar',
+                }
+
+        class Base1A(Base1B):
+            class _meta(object):
+                field_mapping = {
+                    'hello': 'world',
+                }
+
+        class Base2(object):
+            class _meta(object):
+                field_mapping = {
+                    'hello': 'sun',
+                    'something': 'here',
+                }
+
+        class Options(object):
+            field_mapping = {
+                'foo': 'baar',
+                'happy': 'rainbows',
+            }
+
+        mapping = SerializerFormMeta.get_field_mapping((Base1A, Base2), Options)
+
+        self.assertDictEqual(mapping, {
+            'hi': 'there',
+            'hello': 'world',
+            'something': 'here',
+            'base': 'mapping',
+            'foo': 'baar',
+            'happy': 'rainbows',
+        })
+
+    def test_get_form_fields_from_serializer(self):
+        fields = SerializerFormMeta.get_form_fields_from_serializer(
+            (object,), mock.Mock(serializer=TestSerializer,
+                                 fields=['foo', 'bar'],
+                                 exclude=['exclude'],
+                                 field_mapping={})
+        )
+
+        self.assertSetEqual(set(fields.keys()), {'bar'})
+        self.assertIsInstance(fields['bar'], forms.IntegerField)
+
+    def test_get_form_fields_from_serializer_unmapped_field(self):
+        class CustomField(serializers.Field):
+            pass
+
+        class MySerializer(serializers.Serializer):
+            foo = serializers.CharField(read_only=True)
+            bar = CustomField()
+
+        with self.assertRaises(TypeError):
+            SerializerFormMeta.get_form_fields_from_serializer(
+                (object,), mock.Mock(serializer=MySerializer,
+                                     fields=['foo', 'bar'],
+                                     exclude=[],
+                                     field_mapping={})
+            )
+
+    @mock.patch(TESTING_MODULE + '.SerializerFormOptions')
+    def test_new_no_parents(self, mock_serializer_form_options):
+        class TestForm(six.with_metaclass(SerializerFormMeta, forms.Form)):
+            pass
+
+        self.assertFalse(mock_serializer_form_options.called)
+
+    def test_new(self):
+        class TestForm(six.with_metaclass(SerializerFormMeta, SerializerForm)):
+            class Meta(object):
+                serializer = TestSerializer
+                fields = ['bar', 'foo']
+                exclude = ['exclude']
+
+        self.assertIsInstance(TestForm._meta, SerializerFormOptions)
+        self.assertSetEqual(set(TestForm.base_fields.keys()), {'bar'})
+
+
+class TestSerializerFormBase(unittest.TestCase):
+    def test_init(self):
+        self.assertIsNone(SerializerFormBase().serializer)
+
+    def test_get_serializer_context(self):
+        self.assertDictEqual(SerializerFormBase().get_serializer_context(), {})
+
+    def test_get_serializer_data(self):
+        form = SerializerFormBase()
+        form.cleaned_data = {'hello': 'world'}
+        form.initial = {'stuff': 'here', 'hello': 'mars'}
+
+        self.assertDictEqual(form.get_serializer_data(), {
+            'hello': 'world',
+            'stuff': 'here',
+        })
+
+    @mock.patch.object(SerializerFormBase, 'get_serializer_data')
+    @mock.patch.object(SerializerFormBase, 'get_serializer_context')
+    def test_get_serializer(self, mock_get_serializer_context, mock_get_serializer_data):
+        form = SerializerFormBase()
+        mock_serializer = mock.Mock()
+        form._meta = mock.Mock(serializer=mock_serializer)
+
+        actual = form.get_serializer()
+
+        self.assertEqual(actual, mock_serializer.return_value)
+        mock_serializer.assert_called_once_with(
+            data=mock_get_serializer_data.return_value,
+            context=mock_get_serializer_context.return_value,
+        )
+
+    @mock.patch.object(SerializerFormBase, 'get_serializer')
+    def test_clean_form_valid(self, mock_get_serializer):
+        class TestForm(SerializerFormBase):
+            hello = forms.CharField()
+
+        form = TestForm(data={'hello': 'world'})
+        mock_get_serializer.return_value.is_valid.return_value = True
+        mock_get_serializer.return_value.validated_data = {
+            'and': 'mars'
+        }
+
+        self.assertTrue(form.is_valid(), form.errors)
+        self.assertEqual(form.cleaned_data, {
+            'hello': 'world',
+            'and': 'mars',
+        })
+
+    @mock.patch.object(SerializerFormBase, 'get_serializer')
+    def test_clean_form_invalid(self, mock_get_serializer):
+        form = SerializerFormBase(data={})
+        mock_get_serializer.return_value.is_valid.return_value = False
+        mock_get_serializer.return_value.errors = {
+            'field': ['error'],
+        }
+
+        self.assertFalse(form.is_valid(), form.errors)
+
+        self.assertEqual(form.errors, {'field': ['error']})
+
+
+class TestSerializerForm(unittest.TestCase):
+    def test_full_clean_valid(self):
+        data = {
+            'foo': 'anything',
+            'bar': '500',
+            'exclude': '2015-01-01T12:00'
+        }
+        initial = {
+            'exclude': datetime(2016, 1, 1, 16, 30)
+        }
+
+        form = TestForm(data=data, initial=initial)
+
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        self.assertDictEqual(form.cleaned_data, {
+            'bar': 500,
+            'exclude': datetime(2016, 1, 1, 16, 30)
+        })
+
+    def test_full_clean_invalid(self):
+        data = {
+            'foo': 'anything',
+            'bar': '1000',
+            'exclude': '2015-01-01T12:00'
+        }
+        initial = {
+            'exclude': datetime(2016, 1, 1, 16, 30)
+        }
+
+        form = TestForm(data=data, initial=initial)
+
+        self.assertFalse(form.is_valid())
+        self.assertIn('bar', form.errors)
+
+
+class TestUtils(unittest.TestCase):
+    def test_form_from_serializer_not_serializer(self):
+        with self.assertRaises(AssertionError):
+            form_from_serializer(None)
+
+    def test_form_from_serializer(self):
+        form = form_from_serializer(TestSerializer, fields=['foo', 'bar'], exclude=['exclude'])
+
+        self.assertTrue(issubclass(form, SerializerForm))
+        self.assertIsInstance(form._meta, SerializerFormOptions)
+        self.assertListEqual(form._meta.fields, ['foo', 'bar'])
+        self.assertListEqual(form._meta.exclude, ['exclude'])
+        self.assertIs(form._meta.serializer, TestSerializer)

simo/core/drf_braces/tests/serializers/test_enforce_validation_serializer.py

@@ -0,0 +1,169 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import unittest
+
+import mock
+import six
+from rest_framework import fields, serializers
+
+from ...serializers.enforce_validation_serializer import (
+    EnforceValidationFieldMixin,
+    _create_enforce_validation_serializer,
+    add_base_class_to_instance,
+    create_enforce_validation_serializer,
+)
+
+
+TESTING_MODULE = 'drf_braces.serializers.enforce_validation_serializer'
+
+
+class InnerSerializer(serializers.Serializer):
+    field = fields.IntegerField()
+    field2 = fields.IntegerField()
+    must_validate_fields = ['field']
+
+
+class TestSerializer(serializers.Serializer):
+    field = fields.IntegerField()
+    field2 = fields.IntegerField()
+    inner = InnerSerializer()
+
+
+class TestManySerializer(serializers.Serializer):
+    many = TestSerializer(many=True)
+
+
+class CaptureFailedFieldValidationFieldMixin(EnforceValidationFieldMixin):
+
+    def capture_failed_field(self, field_name, field_data, error_msg):
+        self._failed_validation = {field_name: (field_data, error_msg)}
+
+
+class TestEnforceValidationFieldMixin(unittest.TestCase):
+    class Field(EnforceValidationFieldMixin, fields.IntegerField):
+        pass
+
+    class CaptureFailedField(CaptureFailedFieldValidationFieldMixin, fields.TimeField):
+        pass
+
+    def test_run_validation_must_validate(self):
+        field = self.Field()
+        field.field_name = 'field'
+        field.parent = mock.MagicMock(must_validate_fields=None)
+
+        self.assertEqual(field.run_validation('5'), 5)
+
+    def test_run_validation_must_validate_all(self):
+        field = self.Field()
+        field.field_name = 'field'
+        field.parent = mock.MagicMock(must_validate_fields=None)
+
+        with self.assertRaises(serializers.ValidationError):
+            field.run_validation('hello')
+
+    def test_run_validation_must_validate_invalid(self):
+        field = self.Field()
+        field.field_name = 'field'
+        field.parent = mock.MagicMock(must_validate_fields=['field'])
+
+        with self.assertRaises(serializers.ValidationError):
+            field.run_validation('hello')
+
+    def test_run_validation_must_validate_ignore(self):
+        field = self.Field()
+        field.field_name = 'field'
+        field.parent = mock.MagicMock(must_validate_fields=[])
+
+        with self.assertRaises(serializers.SkipField):
+            field.run_validation('hello')
+
+    def test_run_validation_must_validate_ignore_capture(self):
+        field = self.CaptureFailedField()
+        field.field_name = 'field'
+        field.parent = mock.MagicMock(must_validate_fields=[''])
+
+        with self.assertRaises(serializers.SkipField):
+            field.run_validation('Bad Time')
+
+        self.assertEqual('Bad Time', field._failed_validation['field'][0])
+        self.assertIn('Time has wrong format. Use one of these formats instead', six.text_type(field._failed_validation['field'][1]))
+
+
+class TestUtils(unittest.TestCase):
+    def test_add_base_class_to_instance(self):
+        obj = fields.IntegerField(max_value=100)
+
+        self.assertNotIsInstance(obj, EnforceValidationFieldMixin)
+
+        new_obj = add_base_class_to_instance(obj, EnforceValidationFieldMixin)
+
+        self.assertIsInstance(new_obj, EnforceValidationFieldMixin)
+        self.assertEqual(vars(obj), vars(new_obj))
+
+    def test__create_enforce_validation_serializer_instance(self):
+        new_serializer_class = _create_enforce_validation_serializer(
+            TestManySerializer, strict_mode_by_default=False
+        )
+        new_serializer = new_serializer_class(data={
+            'many': [
+                {
+                    'inner': {
+                        'field': '5',
+                        'field2': 'hello',
+                    },
+                    'field': 'hello',
+                    'field2': 'world',
+                },
+            ]
+        })
+
+        self.assertIsInstance(
+            new_serializer.fields['many'].child.fields['field'],
+            EnforceValidationFieldMixin
+        )
+        self.assertIsInstance(
+            new_serializer.fields['many'].child.fields['inner'].fields['field'],
+            EnforceValidationFieldMixin
+        )
+        self.assertListEqual(
+            new_serializer.fields['many'].child.must_validate_fields,
+            []
+        )
+        self.assertEqual(
+            new_serializer.fields['many'].child.fields['inner'].must_validate_fields,
+            ['field']
+        )
+
+        self.assertTrue(new_serializer.is_valid(), new_serializer.errors)
+        self.assertDictEqual(new_serializer.validated_data, {
+            'many': [
+                {
+                    'inner': {
+                        'field': 5,
+                    }
+                }
+            ]
+        })
+
+    @mock.patch(TESTING_MODULE + '._create_enforce_validation_serializer')
+    def test_create_enforce_validation_serializer_direct_decorator(
+            self, mock_create_enforce_validation_serializer):
+        @create_enforce_validation_serializer
+        class OtherSerializer(TestSerializer):
+            pass
+
+        self.assertEqual(OtherSerializer, mock_create_enforce_validation_serializer.return_value)
+        mock_create_enforce_validation_serializer.assert_called_once_with(mock.ANY)
+
+    @mock.patch(TESTING_MODULE + '._create_enforce_validation_serializer')
+    def test_create_enforce_validation_serializer_decorator_params(
+            self, mock_create_enforce_validation_serializer):
+        @create_enforce_validation_serializer(foo='bar')
+        class OtherSerializer(TestSerializer):
+            pass
+
+        self.assertEqual(OtherSerializer, mock_create_enforce_validation_serializer.return_value)
+        mock_create_enforce_validation_serializer.assert_called_once_with(mock.ANY, foo='bar')
+
+    def test_create_enforce_validation_serializer_invalid(self):
+        with self.assertRaises(TypeError):
+            create_enforce_validation_serializer(5)