Exemple #1
0
    def test_is_validated(self):
        form = Form()

        data = {
            form.form_name_value: [form.get_name(), ],
        }
        assert form.validate(data) is True
Exemple #2
0
class GetDataDictTest(TestCase):

    def setUp(self):
        super().setUp()
        self.form = Form()
        self.form.add_field('name1')
        self.form.add_field('name2')

        data = {
            self.form.form_name_value: [self.form.get_name()],
            'name1': ['one'],
            'name2': ['two', 'three'],
        }

        self.form.validate(data)

    def test_dict(self):
        assert self.form.get_data_dict() == {
            'name1': ['one'],
            'name2': ['two', 'three'],
        }

    def test_dict_minified(self):
        assert self.form.get_data_dict(True) == {
            'name1': 'one',
            'name2': ['two', 'three'],
        }
Exemple #3
0
    def test_name_match(self):
        form = Form()
        raw_data = {
            Form.form_name_value: [form.get_name()],
        }

        assert form._is_form_submitted(raw_data) is True
Exemple #4
0
    def test_name_do_not_match(self):
        form = Form()
        raw_data = {
            Form.form_name_value: [form.get_name() + 'bad'],
        }

        assert form._is_form_submitted(raw_data) is False
Exemple #5
0
    def test_if_not_validated(self):
        form = Form()
        form.add_field('name', validators=[NotEmpty()])

        data = {
            form.form_name_value: [form.get_name(), ],
        }
        assert form.validate(data) is False
Exemple #6
0
    def test_messages(self):
        class ExampleTranslation(Translation):

            def translate(self):
                return 'translated!'
        form = Form()
        form.translation_class = ExampleTranslation

        form.add_field('name', validators=[NotEmpty()])

        assert form.validate({
            form.form_name_value: [form.get_name()],
        }) is False

        assert form.fields['name'].messages[0]() == 'translated!'
Exemple #7
0
class GetReportTest(TestCase):

    def setUp(self):
        super().setUp()
        self.form = Form()
        self.form.add_field('name1', validators=[NotEmpty()])
        self.form.add_field('name2', validators=[IsDigit()])
        self.form_validator = ExampleFormValidator()
        self.form.add_form_validator(self.form_validator)

    def run_form(self):
        data = {
            self.form.form_name_value: [self.form.get_name()]
        }
        return self.form.validate(data)

    def test_success(self):
        self.form.parse_dict({
            'name1': ['one'],
        })
        assert self.run_form() is True

        assert self.form.get_report() == {
            'success': True,
            'messages': [],
            'fields': {
                'name1': {
                    'success': True,
                    'messages': [],
                    'values': [{
                        'value': 'one',
                        'success': True,
                        'messages': [],
                    }]
                },
                'name2': {
                    'success': True,
                    'messages': [],
                    'values': []
                },
            }
        }

    def test_error_at_form_validator(self):
        self.form.parse_dict({
            'name1': ['one'],
        })
        self.form_validator._validate = False
        assert self.run_form() is False

        assert self.form.get_report() == {
            'success': False,
            'messages': ['example validator'],
            'fields': {
                'name1': {
                    'success': True,
                    'messages': [],
                    'values': [{
                        'value': 'one',
                        'success': True,
                        'messages': [],
                    }]
                },
                'name2': {
                    'success': True,
                    'messages': [],
                    'values': []
                },
            }
        }

    def test_error_at_field_validator_with_compiling(self):
        self.form.parse_dict({
        })
        assert self.run_form() is False

        assert self.form.get_report() == {
            'success': False,
            'messages': [],
            'fields': {
                'name1': {
                    'success': False,
                    'messages': ['NotEmpty'],
                    'values': []
                },
                'name2': {
                    'success': True,
                    'messages': [],
                    'values': []
                },
            }
        }

    def test_error_at_field_value_validator(self):
        self.form.parse_dict({
            'name1': ['one'],
            'name2': ['three']
        })
        assert self.run_form() is False

        assert self.form.get_report() == {
            'success': False,
            'messages': [],
            'fields': {
                'name1': {
                    'success': True,
                    'messages': [],
                    'values': [{
                        'value': 'one',
                        'success': True,
                        'messages': [],
                    }]
                },
                'name2': {
                    'success': False,
                    'messages': [],
                    'values': [{
                        'value': 'three',
                        'success': False,
                        'messages': ['IsDigit'],
                    }]
                },
            }
        }