Debian Codegraph @

tests/validation/test_unique.py

raw
1 import datetime
2 import unittest
3
4 from django.apps.registry import Apps
5 from django.core.exceptions import ValidationError
6 from django.db import models
7 from django.test import TestCase
8
9 from .models import (
10 CustomPKModel,
11 FlexibleDatePost,
12 ModelToValidate,
13 Post,
14 UniqueErrorsModel,
15 UniqueFieldsModel,
16 UniqueForDateModel,
17 UniqueFuncConstraintModel,
18 UniqueTogetherModel,
19 )
20
21
22 class GetUniqueCheckTests(unittest.TestCase):
23 def test_unique_fields_get_collected(self):
24 m = UniqueFieldsModel()
25 self.assertEqual(
26 (
27 [
28 (UniqueFieldsModel, ("id",)),
29 (UniqueFieldsModel, ("unique_charfield",)),
30 (UniqueFieldsModel, ("unique_integerfield",)),
31 ],
32 [],
33 ),
34 m._get_unique_checks(),
35 )
36
37 def test_unique_together_gets_picked_up_and_converted_to_tuple(self):
38 m = UniqueTogetherModel()
39 self.assertEqual(
40 (
41 [
42 (UniqueTogetherModel, ("ifield", "cfield")),
43 (UniqueTogetherModel, ("ifield", "efield")),
44 (UniqueTogetherModel, ("id",)),
45 ],
46 [],
47 ),
48 m._get_unique_checks(),
49 )
50
51 def test_unique_together_normalization(self):
52 """
53 Test the Meta.unique_together normalization with different sorts of
54 objects.
55 """
56 data = {
57 "2-tuple": (("foo", "bar"), (("foo", "bar"),)),
58 "list": (["foo", "bar"], (("foo", "bar"),)),
59 "already normalized": (
60 (("foo", "bar"), ("bar", "baz")),
61 (("foo", "bar"), ("bar", "baz")),
62 ),
63 "set": (
64 {("foo", "bar"), ("bar", "baz")}, # Ref #21469
65 (("foo", "bar"), ("bar", "baz")),
66 ),
67 }
68
69 for unique_together, normalized in data.values():
70
71 class M(models.Model):
72 foo = models.IntegerField()
73 bar = models.IntegerField()
74 baz = models.IntegerField()
75
76 Meta = type(
77 "Meta", (), {"unique_together": unique_together, "apps": Apps()}
78 )
79
80 checks, _ = M()._get_unique_checks()
81 for t in normalized:
82 check = (M, t)
83 self.assertIn(check, checks)
84
85 def test_primary_key_is_considered_unique(self):
86 m = CustomPKModel()
87 self.assertEqual(
88 ([(CustomPKModel, ("my_pk_field",))], []), m._get_unique_checks()
89 )
90
91 def test_unique_for_date_gets_picked_up(self):
92 m = UniqueForDateModel()
93 self.assertEqual(
94 (
95 [(UniqueForDateModel, ("id",))],
96 [
97 (UniqueForDateModel, "date", "count", "start_date"),
98 (UniqueForDateModel, "year", "count", "end_date"),
99 (UniqueForDateModel, "month", "order", "end_date"),
100 ],
101 ),
102 m._get_unique_checks(),
103 )
104
105 def test_unique_for_date_exclusion(self):
106 m = UniqueForDateModel()
107 self.assertEqual(
108 (
109 [(UniqueForDateModel, ("id",))],
110 [
111 (UniqueForDateModel, "year", "count", "end_date"),
112 (UniqueForDateModel, "month", "order", "end_date"),
113 ],
114 ),
115 m._get_unique_checks(exclude="start_date"),
116 )
117
118 def test_func_unique_constraint_ignored(self):
119 m = UniqueFuncConstraintModel()
120 self.assertEqual(
121 m._get_unique_checks(),
122 ([(UniqueFuncConstraintModel, ("id",))], []),
123 )
124
125
126 class PerformUniqueChecksTest(TestCase):
127 def test_primary_key_unique_check_not_performed_when_adding_and_pk_not_specified(
128 self,
129 ):
130 # Regression test for #12560
131 with self.assertNumQueries(0):
132 mtv = ModelToValidate(number=10, name="Some Name")
133 setattr(mtv, "_adding", True)
134 mtv.full_clean()
135
136 def test_primary_key_unique_check_performed_when_adding_and_pk_specified(self):
137 # Regression test for #12560
138 with self.assertNumQueries(1):
139 mtv = ModelToValidate(number=10, name="Some Name", id=123)
140 setattr(mtv, "_adding", True)
141 mtv.full_clean()
142
143 def test_primary_key_unique_check_not_performed_when_not_adding(self):
144 # Regression test for #12132
145 with self.assertNumQueries(0):
146 mtv = ModelToValidate(number=10, name="Some Name")
147 mtv.full_clean()
148
149 def test_unique_db_default(self):
150 UniqueFieldsModel.objects.create(unique_charfield="foo", non_unique_field=42)
151 um = UniqueFieldsModel(unique_charfield="bar", non_unique_field=42)
152 with self.assertRaises(ValidationError) as cm:
153 um.full_clean()
154 self.assertEqual(
155 cm.exception.message_dict,
156 {
157 "unique_integerfield": [
158 "Unique fields model with this Unique integerfield already exists."
159 ]
160 },
161 )
162
163 def test_unique_for_date(self):
164 Post.objects.create(
165 title="Django 1.0 is released",
166 slug="Django 1.0",
167 subtitle="Finally",
168 posted=datetime.date(2008, 9, 3),
169 )
170 p = Post(title="Django 1.0 is released", posted=datetime.date(2008, 9, 3))
171 with self.assertRaises(ValidationError) as cm:
172 p.full_clean()
173 self.assertEqual(
174 cm.exception.message_dict,
175 {"title": ["Title must be unique for Posted date."]},
176 )
177
178 # Should work without errors
179 p = Post(title="Work on Django 1.1 begins", posted=datetime.date(2008, 9, 3))
180 p.full_clean()
181
182 # Should work without errors
183 p = Post(title="Django 1.0 is released", posted=datetime.datetime(2008, 9, 4))
184 p.full_clean()
185
186 p = Post(slug="Django 1.0", posted=datetime.datetime(2008, 1, 1))
187 with self.assertRaises(ValidationError) as cm:
188 p.full_clean()
189 self.assertEqual(
190 cm.exception.message_dict,
191 {"slug": ["Slug must be unique for Posted year."]},
192 )
193
194 p = Post(subtitle="Finally", posted=datetime.datetime(2008, 9, 30))
195 with self.assertRaises(ValidationError) as cm:
196 p.full_clean()
197 self.assertEqual(
198 cm.exception.message_dict,
199 {"subtitle": ["Subtitle must be unique for Posted month."]},
200 )
201
202 p = Post(title="Django 1.0 is released")
203 with self.assertRaises(ValidationError) as cm:
204 p.full_clean()
205 self.assertEqual(
206 cm.exception.message_dict, {"posted": ["This field cannot be null."]}
207 )
208
209 def test_unique_for_date_with_nullable_date(self):
210 """
211 unique_for_date/year/month checks shouldn't trigger when the
212 associated DateField is None.
213 """
214 FlexibleDatePost.objects.create(
215 title="Django 1.0 is released",
216 slug="Django 1.0",
217 subtitle="Finally",
218 posted=datetime.date(2008, 9, 3),
219 )
220 p = FlexibleDatePost(title="Django 1.0 is released")
221 p.full_clean()
222
223 p = FlexibleDatePost(slug="Django 1.0")
224 p.full_clean()
225
226 p = FlexibleDatePost(subtitle="Finally")
227 p.full_clean()
228
229 def test_unique_errors(self):
230 UniqueErrorsModel.objects.create(name="Some Name", no=10)
231 m = UniqueErrorsModel(name="Some Name", no=11)
232 with self.assertRaises(ValidationError) as cm:
233 m.full_clean()
234 self.assertEqual(
235 cm.exception.message_dict, {"name": ["Custom unique name message."]}
236 )
237
238 m = UniqueErrorsModel(name="Some Other Name", no=10)
239 with self.assertRaises(ValidationError) as cm:
240 m.full_clean()
241 self.assertEqual(
242 cm.exception.message_dict, {"no": ["Custom unique number message."]}
243 )