← Back to branch summary

~ubuntu-branches/ubuntu/saucy/python-django/saucy-updates

« back to all changes in this revision

Viewing changes to tests/modeltests/validation/test_error_messages.py

  • Committer: Package Import Robot
  • Author(s): Luke Faraone, Jakub Wilk, Luke Faraone
  • Date: 2013-05-09 15:10:47 UTC
  • mfrom: (1.1.21) (4.4.27 sid)
  • Revision ID: package-import@ubuntu.com-20130509151047-aqv8d71oj9wvcv8c
Tags: 1.5.1-2
[ Jakub Wilk ]
* Use canonical URIs for Vcs-* fields.

[ Luke Faraone ]
* Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/modeltests/validation/test_error_messages.py
 
1
# -*- encoding: utf-8 -*-
 
2
from __future__ import unicode_literals
 
3
 
1
4
from django.core.exceptions import ValidationError
2
5
from django.db import models
 
6
from django.utils import six
3
7
from django.utils.unittest import TestCase
4
8
 
5
9
 
6
10
class ValidationMessagesTest(TestCase):
7
11
 
 
12
    def _test_validation_messages(self, field, value, expected):
 
13
        with self.assertRaises(ValidationError) as cm:
 
14
            field.clean(value, None)
 
15
        self.assertEqual(cm.exception.messages, expected)
 
16
 
8
17
    def test_autofield_field_raises_error_message(self):
9
18
        f = models.AutoField(primary_key=True)
10
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
11
 
        try:
12
 
            f.clean('foo', None)
13
 
        except ValidationError, e:
14
 
            self.assertEqual(e.messages, [u"'foo' value must be an integer."])
 
19
        self._test_validation_messages(f, 'fõo',
 
20
            ["'fõo' value must be an integer."])
15
21
        # primary_key must be True. Refs #12467.
16
 
        self.assertRaises(AssertionError, models.AutoField, 'primary_key', False)
17
 
        try:
 
22
        with six.assertRaisesRegex(self, AssertionError,
 
23
                "AutoFields must have primary_key=True."):
18
24
            models.AutoField(primary_key=False)
19
 
        except AssertionError, e:
20
 
            self.assertEqual(str(e), "AutoFields must have primary_key=True.")
21
25
 
22
26
    def test_integer_field_raises_error_message(self):
23
27
        f = models.IntegerField()
24
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
25
 
        try:
26
 
            f.clean('foo', None)
27
 
        except ValidationError, e:
28
 
            self.assertEqual(e.messages, [u"'foo' value must be an integer."])
 
28
        self._test_validation_messages(f, 'fõo',
 
29
            ["'fõo' value must be an integer."])
29
30
 
30
31
    def test_boolean_field_raises_error_message(self):
31
32
        f = models.BooleanField()
32
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
33
 
        try:
34
 
            f.clean('foo', None)
35
 
        except ValidationError, e:
36
 
            self.assertEqual(e.messages,
37
 
                        [u"'foo' value must be either True or False."])
 
33
        self._test_validation_messages(f, 'fõo',
 
34
            ["'fõo' value must be either True or False."])
38
35
 
39
36
    def test_float_field_raises_error_message(self):
40
37
        f = models.FloatField()
41
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
42
 
        try:
43
 
            f.clean('foo', None)
44
 
        except ValidationError, e:
45
 
            self.assertEqual(e.messages, [u"'foo' value must be a float."])
 
38
        self._test_validation_messages(f, 'fõo',
 
39
            ["'fõo' value must be a float."])
46
40
 
47
41
    def test_decimal_field_raises_error_message(self):
48
42
        f = models.DecimalField()
49
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
50
 
        try:
51
 
            f.clean('foo', None)
52
 
        except ValidationError, e:
53
 
            self.assertEqual(e.messages,
54
 
                        [u"'foo' value must be a decimal number."])
 
43
        self._test_validation_messages(f, 'fõo',
 
44
            ["'fõo' value must be a decimal number."])
55
45
 
56
46
    def test_null_boolean_field_raises_error_message(self):
57
47
        f = models.NullBooleanField()
58
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
59
 
        try:
60
 
            f.clean('foo', None)
61
 
        except ValidationError, e:
62
 
            self.assertEqual(e.messages,
63
 
                        [u"'foo' value must be either None, True or False."])
 
48
        self._test_validation_messages(f, 'fõo',
 
49
            ["'fõo' value must be either None, True or False."])
64
50
 
65
51
    def test_date_field_raises_error_message(self):
66
52
        f = models.DateField()
67
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
68
 
        try:
69
 
            f.clean('foo', None)
70
 
        except ValidationError, e:
71
 
            self.assertEqual(e.messages, [
72
 
                u"'foo' value has an invalid date format. "
73
 
                u"It must be in YYYY-MM-DD format."])
74
 
 
75
 
        self.assertRaises(ValidationError, f.clean, 'aaaa-10-10', None)
76
 
        try:
77
 
            f.clean('aaaa-10-10', None)
78
 
        except ValidationError, e:
79
 
            self.assertEqual(e.messages, [
80
 
                u"'aaaa-10-10' value has an invalid date format. "
81
 
                u"It must be in YYYY-MM-DD format."])
82
 
 
83
 
        self.assertRaises(ValidationError, f.clean, '2011-13-10', None)
84
 
        try:
85
 
            f.clean('2011-13-10', None)
86
 
        except ValidationError, e:
87
 
            self.assertEqual(e.messages, [
88
 
                u"'2011-13-10' value has the correct format (YYYY-MM-DD) "
89
 
                u"but it is an invalid date."])
90
 
 
91
 
        self.assertRaises(ValidationError, f.clean, '2011-10-32', None)
92
 
        try:
93
 
            f.clean('2011-10-32', None)
94
 
        except ValidationError, e:
95
 
            self.assertEqual(e.messages, [
96
 
                u"'2011-10-32' value has the correct format (YYYY-MM-DD) "
97
 
                u"but it is an invalid date."])
 
53
        self._test_validation_messages(f, 'fõo',
 
54
            ["'fõo' value has an invalid date format. "
 
55
             "It must be in YYYY-MM-DD format."])
 
56
 
 
57
        self._test_validation_messages(f, 'aaaa-10-10',
 
58
            ["'aaaa-10-10' value has an invalid date format. "
 
59
             "It must be in YYYY-MM-DD format."])
 
60
 
 
61
        self._test_validation_messages(f, '2011-13-10',
 
62
            ["'2011-13-10' value has the correct format (YYYY-MM-DD) "
 
63
             "but it is an invalid date."])
 
64
 
 
65
        self._test_validation_messages(f, '2011-10-32',
 
66
            ["'2011-10-32' value has the correct format (YYYY-MM-DD) "
 
67
             "but it is an invalid date."])
98
68
 
99
69
    def test_datetime_field_raises_error_message(self):
100
70
        f = models.DateTimeField()
101
71
        # Wrong format
102
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
103
 
        try:
104
 
            f.clean('foo', None)
105
 
        except ValidationError, e:
106
 
            self.assertEqual(e.messages, [
107
 
                u"'foo' value has an invalid format. It must be "
108
 
                u"in YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format."])
 
72
        self._test_validation_messages(f, 'fõo',
 
73
            ["'fõo' value has an invalid format. It must be "
 
74
             "in YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format."])
109
75
 
110
76
        # Correct format but invalid date
111
 
        self.assertRaises(ValidationError, f.clean, '2011-10-32', None)
112
 
        try:
113
 
            f.clean('2011-10-32', None)
114
 
        except ValidationError, e:
115
 
            self.assertEqual(e.messages, [
116
 
                u"'2011-10-32' value has the correct format "
117
 
                u"(YYYY-MM-DD) but it is an invalid date."])
 
77
        self._test_validation_messages(f, '2011-10-32',
 
78
            ["'2011-10-32' value has the correct format "
 
79
             "(YYYY-MM-DD) but it is an invalid date."])
118
80
 
119
81
        # Correct format but invalid date/time
120
 
        self.assertRaises(ValidationError, f.clean, '2011-10-32 10:10', None)
121
 
        try:
122
 
            f.clean('2011-10-32 10:10', None)
123
 
        except ValidationError, e:
124
 
            self.assertEqual(e.messages, [
125
 
                u"'2011-10-32 10:10' value has the correct format "
126
 
                u"(YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]) "
127
 
                u"but it is an invalid date/time."])
 
82
        self._test_validation_messages(f, '2011-10-32 10:10',
 
83
            ["'2011-10-32 10:10' value has the correct format "
 
84
             "(YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]) "
 
85
             "but it is an invalid date/time."])
128
86
 
129
87
    def test_time_field_raises_error_message(self):
130
88
        f = models.TimeField()
131
89
        # Wrong format
132
 
        self.assertRaises(ValidationError, f.clean, 'foo', None)
133
 
        try:
134
 
            f.clean('foo', None)
135
 
        except ValidationError, e:
136
 
            self.assertEqual(e.messages, [
137
 
                u"'foo' value has an invalid format. It must be in "
138
 
                u"HH:MM[:ss[.uuuuuu]] format."])
 
90
        self._test_validation_messages(f, 'fõo',
 
91
            ["'fõo' value has an invalid format. It must be in "
 
92
             "HH:MM[:ss[.uuuuuu]] format."])
 
93
 
139
94
        # Correct format but invalid time
140
 
        self.assertRaises(ValidationError, f.clean, '25:50', None)
141
 
        try:
142
 
            f.clean('25:50', None)
143
 
        except ValidationError, e:
144
 
            self.assertEqual(e.messages, [
145
 
                u"'25:50' value has the correct format "
146
 
                u"(HH:MM[:ss[.uuuuuu]]) but it is an invalid time."])
 
95
        self._test_validation_messages(f, '25:50',
 
96
            ["'25:50' value has the correct format "
 
97
             "(HH:MM[:ss[.uuuuuu]]) but it is an invalid time."])