Merge pull request #177 from novafloss/confirmation-preset-tests

mgu · web-flow · commit d57a512e0348 · 2017-03-01T16:08:37.000+01:00
Confirmation preset tests
diff --git a/demo/tests/test_end_point.py b/demo/tests/test_end_point.py
@@ -528,6 +528,18 @@ class CreateSerializerTestCase(TestCase):
         }],
     }]
 
+    invalid_presets = [{
+        'preset_id': 'unknown',
+        'message': 'not the same',
+        'arguments': [{
+            'slug': 'left',
+            'field_id': 'input-date',
+        }, {
+            'slug': 'right',
+            'field_id': 'text_input',
+        }],
+    }]
+
     presets_with_wrong_parameters = [{
         'preset_id': 'confirmation',
         'message': 'noteq!',
@@ -601,6 +613,17 @@ def test_create_form_presets(self):
                 slug='right', field_id='text_input').exists()
         )
 
+    def test_create_form_presets_invalid_preset(self):
+        data = copy.deepcopy(self.data)
+        data['fields'] = copy.deepcopy(self.fields_with_validation)
+        data['presets'] = copy.deepcopy(self.invalid_presets)
+        serializer = FormidableSerializer(data=data)
+        self.assertFalse(serializer.is_valid(), serializer.errors)
+        self.assertEqual(
+            serializer.errors['presets'][0]['preset_id'][0],
+            'unknown is not an available preset'  # noqa
+        )
+
     def test_create_form_with_presets_invalid_argument(self):
         data = copy.deepcopy(self.data)
         data['presets'] = copy.deepcopy(self.presets_with_wrong_parameters)
@@ -1232,7 +1255,10 @@ def test_render_preset_hybrid_arg(self):
         self.assertIn('field', data['types'])
 
     def test_render_preset_with_argument(self):
-        preset_instance = self.PresetsTestWithArgs(arguments=[])
+        preset_instance = self.PresetsTestWithArgs(arguments=[
+            PresetArg(slug='lhs', field_id='foo'),
+            PresetArg(slug='rhs', value='toto'),
+        ])
         serializer = PresetsSerializer(preset_instance)
         self.assertTrue(serializer.data)
         data = serializer.data
diff --git a/demo/tests/test_forms.py b/demo/tests/test_forms.py
@@ -781,6 +781,75 @@ def test_from_json_raised_error(self):
 
 class TestInnerPresets(TestCase):
 
+    def test_confirmation_fields(self):
+        class TestPresets(FormidableForm):
+            left = fields.IntegerField()
+            right = fields.IntegerField()
+
+            class Meta:
+                presets = [
+                    ConfirmationPresets(
+                        [PresetArg(slug='left', field_id='left'),
+                         PresetArg(slug='right', field_id='right')],
+                    ),
+                ]
+
+        formidable = TestPresets.to_formidable(label='presets')
+        form_class = formidable.get_django_form_class()
+        form = form_class(data={'left': 42, 'right': 42})
+        self.assertTrue(form.is_valid())
+        form = form_class(data={'left': 42, 'right': "42"})
+        self.assertTrue(form.is_valid())
+        form = form_class(data={'left': 42, 'right': 21})
+        self.assertFalse(form.is_valid())
+        form = form_class(data={'left': 42, 'right': "21"})
+        self.assertFalse(form.is_valid())
+
+    def test_confirmation_value(self):
+        class TestPresets(FormidableForm):
+            number = fields.IntegerField()
+
+            class Meta:
+                presets = [
+                    ConfirmationPresets(
+                        [PresetArg(slug='left', field_id='number'),
+                         PresetArg(slug='right', value='42')],
+                    ),
+                ]
+
+        formidable = TestPresets.to_formidable(label='presets')
+        form_class = formidable.get_django_form_class()
+        form = form_class(data={'number': 33})
+        self.assertFalse(form.is_valid())
+        self.assertEqual(
+            form.errors,
+            {'__all__': ['33 is not equal to 42']}
+        )
+
+        form = form_class(data={'number': 42})
+        # 42 should equal 42...
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_confirmation_access(self):
+        class TestPresets(FormidableForm):
+            number = fields.IntegerField(accesses={
+                'jedi': HIDDEN,
+            })
+
+            class Meta:
+                presets = [
+                    ConfirmationPresets(
+                        [PresetArg(slug='left', field_id='number'),
+                         PresetArg(slug='right', value='42')],
+                    ),
+                ]
+
+        formidable = TestPresets.to_formidable(label='presets')
+        form_class = formidable.get_django_form_class(role='jedi')
+        form = form_class(data={'number': 33})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(len(form.rules), 0)
+
     def test_confirmation_not_required_field(self):
         class TestPresets(FormidableForm):
             number = fields.IntegerField(accesses={
diff --git a/demo/tests/test_presets.py b/demo/tests/test_presets.py
@@ -55,19 +55,15 @@ def test_missing_left_operand(self):
         args = [
             PresetArg(slug='right', field_id='confirm_password')
         ]
-        rule = ConfirmationPresets(args)
-        cleaned_data = {'password': 'toto', 'confirm_password': 'tutu'}
         with self.assertRaises(ImproperlyConfigured):
-            self.assertTrue(rule(cleaned_data))
+            ConfirmationPresets(args)
 
     def test_missing_right_operand(self):
         args = [
             PresetArg(slug='left', field_id='password'),
         ]
-        rule = ConfirmationPresets(args)
-        cleaned_data = {'password': 'toto', 'confirm_password': 'tutu'}
         with self.assertRaises(ImproperlyConfigured):
-            self.assertTrue(rule(cleaned_data))
+            ConfirmationPresets(args)
 
     def test_comparison_eq_ok(self):
         args = [
diff --git a/formidable/forms/__init__.py b/formidable/forms/__init__.py
@@ -100,7 +100,7 @@ def get_dynamic_form_class(formidable, role=None, field_factory=None):
         else:
             attrs[field.slug] = form_field
 
-    attrs['rules'] = presets_register.build_rules(formidable)
+    attrs['rules'] = presets_register.build_rules(formidable, attrs)
     return type(str('DynamicForm'), (BaseDynamicForm,), attrs)
 
 
diff --git a/formidable/forms/validations/presets.py b/formidable/forms/validations/presets.py
@@ -4,7 +4,9 @@
 
 from collections import OrderedDict
 
-from django.core.exceptions import ImproperlyConfigured, ValidationError
+from django.core.exceptions import (
+    FieldError, ImproperlyConfigured, ValidationError
+)
 from django.utils.translation import ugettext_lazy as _
 
 import six
@@ -14,13 +16,19 @@
 
 class PresetsRegister(dict):
 
-    def build_rules(self, form):
-        return list(self.gen_rules(form))
+    def build_rules(self, form, fields):
+        return list(self.gen_rules(form, fields))
 
-    def gen_rules(self, form):
+    def gen_rules(self, form, fields):
         for preset in form.presets.all():
             klass = self[preset.slug]
-            yield klass(preset.arguments.all(), message=preset.message)
+            try:
+                yield klass(preset.arguments.all(),
+                            fields=fields, message=preset.message)
+            except FieldError:
+                # preset defined on a field that is filtered (current role
+                # does not match the accesses)
+                pass
 
 
 presets_register = PresetsRegister()
@@ -71,7 +79,7 @@ def __new__(mcls, name, base, attrs):
 
 class PresetArgument(object):
 
-    def __init__(self, label, slug=None, order=None,
+    def __init__(self, label, slug=None, order=None, cast_value_with=None,
                  help_text='', placeholder='', items=None):
         self.slug = slug
         self.label = label
@@ -81,6 +89,7 @@ def __init__(self, label, slug=None, order=None,
         self.has_items = items is not None
         self.items = items or {}
         self.order = order
+        self.cast_value_with = cast_value_with
 
     def get_types(self):
         return [self.__class__.type_]
@@ -92,29 +101,18 @@ def set_slug(self, slug):
         if self.slug is None:
             self.slug = slug
 
-    def get_value(self, arguments, fields):
-
-        for arg in arguments:
-            if arg.slug == self.slug:
-                if arg.field_id:
-                    return fields[arg.field_id]
-                return arg.value
-
-        raise ImproperlyConfigured(
-            _('{slug} is missing').format(slug=self.slug)
-        )
+    def get_value(self, arguments, data):
+        arg = arguments[self.slug]
+        if arg.field_id:
+            return data[arg.field_id]
+        return arg.value
 
     def to_formidable(self, preset, arguments):
 
-        for arg in arguments:
-            if arg.slug == self.slug:
-                arg.preset = preset
-                arg.save()
-                return arg
-
-        raise ImproperlyConfigured(
-            '{slug} is missing'.format(slug=self.slug)
-        )
+        arg = arguments[self.slug]
+        arg.preset = preset
+        arg.save()
+        return arg
 
 
 class PresetFieldArgument(PresetArgument):
@@ -143,16 +141,53 @@ class Presets(six.with_metaclass(PresetsMetaClass)):
     class MetaParameters:
         pass
 
-    def __init__(self, arguments, message=None):
-        self.arguments = arguments
+    def __init__(self, arguments, fields=None, message=None):
         self.message = message or self.default_message
+        # Check if `arguments` match `self._declared_arguments`
+        decl_args_set = set(self._declared_arguments.keys())
+        args_set = {a.slug for a in arguments}
+        missing_args = decl_args_set - args_set
+        if missing_args:
+            raise ImproperlyConfigured(
+                _('Missing presets arguments : {}').format(
+                    ', '.join(missing_args))
+                )
+        extra_args = args_set - decl_args_set
+        if extra_args:
+            raise ImproperlyConfigured(
+                _('Extra presets arguments : {}').format(
+                    ', '.join(extra_args))
+                )
+        self.arguments = {arg.slug: arg for arg in arguments}
+
+        if fields is not None:
+            # Check if `arguments` references to fields are valid
+            required_fields = {
+                a.field_id
+                for a in self.arguments.values()
+                if a.field_id
+            }
+            missing_fields = required_fields - set(fields.keys())
+            if missing_fields:
+                raise FieldError(
+                    _('Bad field references in presets : {}').format(
+                        ', '.join(missing_fields))
+                    )
+            # Value conversions
+            for arg_name, arg in self._declared_arguments.items():
+                instance = self.arguments[arg_name]
+                if arg.cast_value_with and instance.value is not None:
+                    field_name = self.arguments[arg.cast_value_with].field_id
+                    reference_field = fields[field_name]
+                    instance.value = reference_field.to_python(instance.value)
 
     def has_empty_fields(self, cleaned_data):
         def is_empty_value(data):
             return (data is None or
                     (isinstance(data, six.string_types) and not data))
 
-        used_fields = {a.field_id for a in self.arguments if a.field_id}
+        used_fields = {a.field_id
+                       for a in self.arguments.values() if a.field_id}
         # we do not filter out required fields because they can't be empty
         return any(
             is_empty_value(cleaned_data.get(name, None))
@@ -202,7 +237,8 @@ class MetaParameters:
             _('Reference'), help_text=_('field to compare'), order=0
         )
         right = PresetFieldOrValueArgument(
-            _('Compare to'), help_text=_('compare with'), order=1
+            _('Compare to'), help_text=_('compare with'), order=1,
+            cast_value_with='left'
         )
 
     def run(self, left, right):
