Debian Codegraph @

tests/test_exceptions/test_validation_error.py

raw
1 import unittest
2 from unittest import mock
3
4 from django.core.exceptions import ValidationError
5
6
7 class TestValidationError(unittest.TestCase):
8 def test_messages_concatenates_error_dict_values(self):
9 message_dict = {}
10 exception = ValidationError(message_dict)
11 self.assertEqual(sorted(exception.messages), [])
12 message_dict["field1"] = ["E1", "E2"]
13 exception = ValidationError(message_dict)
14 self.assertEqual(sorted(exception.messages), ["E1", "E2"])
15 message_dict["field2"] = ["E3", "E4"]
16 exception = ValidationError(message_dict)
17 self.assertEqual(sorted(exception.messages), ["E1", "E2", "E3", "E4"])
18
19 def test_eq(self):
20 error1 = ValidationError("message")
21 error2 = ValidationError("message", code="my_code1")
22 error3 = ValidationError("message", code="my_code2")
23 error4 = ValidationError(
24 "error %(parm1)s %(parm2)s",
25 code="my_code1",
26 params={"parm1": "val1", "parm2": "val2"},
27 )
28 error5 = ValidationError({"field1": "message", "field2": "other"})
29 error6 = ValidationError({"field1": "message"})
30 error7 = ValidationError(
31 [
32 ValidationError({"field1": "field error", "field2": "other"}),
33 "message",
34 ]
35 )
36
37 self.assertEqual(error1, ValidationError("message"))
38 self.assertNotEqual(error1, ValidationError("message2"))
39 self.assertNotEqual(error1, error2)
40 self.assertNotEqual(error1, error4)
41 self.assertNotEqual(error1, error5)
42 self.assertNotEqual(error1, error6)
43 self.assertNotEqual(error1, error7)
44 self.assertEqual(error1, mock.ANY)
45 self.assertEqual(error2, ValidationError("message", code="my_code1"))
46 self.assertNotEqual(error2, ValidationError("other", code="my_code1"))
47 self.assertNotEqual(error2, error3)
48 self.assertNotEqual(error2, error4)
49 self.assertNotEqual(error2, error5)
50 self.assertNotEqual(error2, error6)
51 self.assertNotEqual(error2, error7)
52
53 self.assertEqual(
54 error4,
55 ValidationError(
56 "error %(parm1)s %(parm2)s",
57 code="my_code1",
58 params={"parm1": "val1", "parm2": "val2"},
59 ),
60 )
61 self.assertNotEqual(
62 error4,
63 ValidationError(
64 "error %(parm1)s %(parm2)s",
65 code="my_code2",
66 params={"parm1": "val1", "parm2": "val2"},
67 ),
68 )
69 self.assertNotEqual(
70 error4,
71 ValidationError(
72 "error %(parm1)s %(parm2)s",
73 code="my_code1",
74 params={"parm2": "val2"},
75 ),
76 )
77 self.assertNotEqual(
78 error4,
79 ValidationError(
80 "error %(parm1)s %(parm2)s",
81 code="my_code1",
82 params={"parm2": "val1", "parm1": "val2"},
83 ),
84 )
85 self.assertNotEqual(
86 error4,
87 ValidationError(
88 "error val1 val2",
89 code="my_code1",
90 ),
91 )
92 # params ordering is ignored.
93 self.assertEqual(
94 error4,
95 ValidationError(
96 "error %(parm1)s %(parm2)s",
97 code="my_code1",
98 params={"parm2": "val2", "parm1": "val1"},
99 ),
100 )
101
102 self.assertEqual(
103 error5,
104 ValidationError({"field1": "message", "field2": "other"}),
105 )
106 self.assertNotEqual(
107 error5,
108 ValidationError({"field1": "message", "field2": "other2"}),
109 )
110 self.assertNotEqual(
111 error5,
112 ValidationError({"field1": "message", "field3": "other"}),
113 )
114 self.assertNotEqual(error5, error6)
115 # fields ordering is ignored.
116 self.assertEqual(
117 error5,
118 ValidationError({"field2": "other", "field1": "message"}),
119 )
120
121 self.assertNotEqual(error7, ValidationError(error7.error_list[1:]))
122 self.assertNotEqual(
123 ValidationError(["message"]),
124 ValidationError([ValidationError("message", code="my_code")]),
125 )
126 # messages ordering is ignored.
127 self.assertEqual(
128 error7,
129 ValidationError(list(reversed(error7.error_list))),
130 )
131
132 self.assertNotEqual(error4, ValidationError([error4]))
133 self.assertNotEqual(ValidationError([error4]), error4)
134 self.assertNotEqual(error4, ValidationError({"field1": error4}))
135 self.assertNotEqual(ValidationError({"field1": error4}), error4)
136
137 def test_eq_nested(self):
138 error_dict = {
139 "field1": ValidationError(
140 "error %(parm1)s %(parm2)s",
141 code="my_code",
142 params={"parm1": "val1", "parm2": "val2"},
143 ),
144 "field2": "other",
145 }
146 error = ValidationError(error_dict)
147 self.assertEqual(error, ValidationError(dict(error_dict)))
148 self.assertEqual(
149 error,
150 ValidationError(
151 {
152 "field1": ValidationError(
153 "error %(parm1)s %(parm2)s",
154 code="my_code",
155 params={"parm2": "val2", "parm1": "val1"},
156 ),
157 "field2": "other",
158 }
159 ),
160 )
161 self.assertNotEqual(
162 error,
163 ValidationError(
164 {**error_dict, "field2": "message"},
165 ),
166 )
167 self.assertNotEqual(
168 error,
169 ValidationError(
170 {
171 "field1": ValidationError(
172 "error %(parm1)s val2",
173 code="my_code",
174 params={"parm1": "val1"},
175 ),
176 "field2": "other",
177 }
178 ),
179 )
180
181 def test_hash(self):
182 error1 = ValidationError("message")
183 error2 = ValidationError("message", code="my_code1")
184 error3 = ValidationError("message", code="my_code2")
185 error4 = ValidationError(
186 "error %(parm1)s %(parm2)s",
187 code="my_code1",
188 params={"parm1": "val1", "parm2": "val2"},
189 )
190 error5 = ValidationError({"field1": "message", "field2": "other"})
191 error6 = ValidationError({"field1": "message"})
192 error7 = ValidationError(
193 [
194 ValidationError({"field1": "field error", "field2": "other"}),
195 "message",
196 ]
197 )
198
199 self.assertEqual(hash(error1), hash(ValidationError("message")))
200 self.assertNotEqual(hash(error1), hash(ValidationError("message2")))
201 self.assertNotEqual(hash(error1), hash(error2))
202 self.assertNotEqual(hash(error1), hash(error4))
203 self.assertNotEqual(hash(error1), hash(error5))
204 self.assertNotEqual(hash(error1), hash(error6))
205 self.assertNotEqual(hash(error1), hash(error7))
206 self.assertEqual(
207 hash(error2),
208 hash(ValidationError("message", code="my_code1")),
209 )
210 self.assertNotEqual(
211 hash(error2),
212 hash(ValidationError("other", code="my_code1")),
213 )
214 self.assertNotEqual(hash(error2), hash(error3))
215 self.assertNotEqual(hash(error2), hash(error4))
216 self.assertNotEqual(hash(error2), hash(error5))
217 self.assertNotEqual(hash(error2), hash(error6))
218 self.assertNotEqual(hash(error2), hash(error7))
219
220 self.assertEqual(
221 hash(error4),
222 hash(
223 ValidationError(
224 "error %(parm1)s %(parm2)s",
225 code="my_code1",
226 params={"parm1": "val1", "parm2": "val2"},
227 )
228 ),
229 )
230 self.assertNotEqual(
231 hash(error4),
232 hash(
233 ValidationError(
234 "error %(parm1)s %(parm2)s",
235 code="my_code2",
236 params={"parm1": "val1", "parm2": "val2"},
237 )
238 ),
239 )
240 self.assertNotEqual(
241 hash(error4),
242 hash(
243 ValidationError(
244 "error %(parm1)s %(parm2)s",
245 code="my_code1",
246 params={"parm2": "val2"},
247 )
248 ),
249 )
250 self.assertNotEqual(
251 hash(error4),
252 hash(
253 ValidationError(
254 "error %(parm1)s %(parm2)s",
255 code="my_code1",
256 params={"parm2": "val1", "parm1": "val2"},
257 )
258 ),
259 )
260 self.assertNotEqual(
261 hash(error4),
262 hash(
263 ValidationError(
264 "error val1 val2",
265 code="my_code1",
266 )
267 ),
268 )
269 # params ordering is ignored.
270 self.assertEqual(
271 hash(error4),
272 hash(
273 ValidationError(
274 "error %(parm1)s %(parm2)s",
275 code="my_code1",
276 params={"parm2": "val2", "parm1": "val1"},
277 )
278 ),
279 )
280
281 self.assertEqual(
282 hash(error5),
283 hash(ValidationError({"field1": "message", "field2": "other"})),
284 )
285 self.assertNotEqual(
286 hash(error5),
287 hash(ValidationError({"field1": "message", "field2": "other2"})),
288 )
289 self.assertNotEqual(
290 hash(error5),
291 hash(ValidationError({"field1": "message", "field3": "other"})),
292 )
293 self.assertNotEqual(error5, error6)
294 # fields ordering is ignored.
295 self.assertEqual(
296 hash(error5),
297 hash(ValidationError({"field2": "other", "field1": "message"})),
298 )
299
300 self.assertNotEqual(
301 hash(error7),
302 hash(ValidationError(error7.error_list[1:])),
303 )
304 self.assertNotEqual(
305 hash(ValidationError(["message"])),
306 hash(ValidationError([ValidationError("message", code="my_code")])),
307 )
308 # messages ordering is ignored.
309 self.assertEqual(
310 hash(error7),
311 hash(ValidationError(list(reversed(error7.error_list)))),
312 )
313
314 self.assertNotEqual(hash(error4), hash(ValidationError([error4])))
315 self.assertNotEqual(hash(ValidationError([error4])), hash(error4))
316 self.assertNotEqual(
317 hash(error4),
318 hash(ValidationError({"field1": error4})),
319 )
320
321 def test_hash_nested(self):
322 error_dict = {
323 "field1": ValidationError(
324 "error %(parm1)s %(parm2)s",
325 code="my_code",
326 params={"parm2": "val2", "parm1": "val1"},
327 ),
328 "field2": "other",
329 }
330 error = ValidationError(error_dict)
331 self.assertEqual(hash(error), hash(ValidationError(dict(error_dict))))
332 self.assertEqual(
333 hash(error),
334 hash(
335 ValidationError(
336 {
337 "field1": ValidationError(
338 "error %(parm1)s %(parm2)s",
339 code="my_code",
340 params={"parm1": "val1", "parm2": "val2"},
341 ),
342 "field2": "other",
343 }
344 )
345 ),
346 )
347 self.assertNotEqual(
348 hash(error),
349 hash(
350 ValidationError(
351 {**error_dict, "field2": "message"},
352 )
353 ),
354 )
355 self.assertNotEqual(
356 hash(error),
357 hash(
358 ValidationError(
359 {
360 "field1": ValidationError(
361 "error %(parm1)s val2",
362 code="my_code",
363 params={"parm1": "val1"},
364 ),
365 "field2": "other",
366 }
367 )
368 ),
369 )