Debian Codegraph @

tests/utils_tests/test_datastructures.py

raw
1 """
2 Tests for stuff in django.utils.datastructures.
3 """
4
5 import collections.abc
6 import copy
7 import pickle
8
9 from django.test import SimpleTestCase
10 from django.utils.datastructures import (
11 CaseInsensitiveMapping,
12 DictWrapper,
13 ImmutableList,
14 MultiValueDict,
15 MultiValueDictKeyError,
16 OrderedSet,
17 )
18
19
20 class OrderedSetTests(SimpleTestCase):
21 def test_init_with_iterable(self):
22 s = OrderedSet([1, 2, 3])
23 self.assertEqual(list(s.dict.keys()), [1, 2, 3])
24
25 def test_remove(self):
26 s = OrderedSet()
27 self.assertEqual(len(s), 0)
28 s.add(1)
29 s.add(2)
30 s.remove(2)
31 self.assertEqual(len(s), 1)
32 self.assertNotIn(2, s)
33
34 def test_discard(self):
35 s = OrderedSet()
36 self.assertEqual(len(s), 0)
37 s.add(1)
38 s.discard(2)
39 self.assertEqual(len(s), 1)
40
41 def test_reversed(self):
42 s = reversed(OrderedSet([1, 2, 3]))
43 self.assertIsInstance(s, collections.abc.Iterator)
44 self.assertEqual(list(s), [3, 2, 1])
45
46 def test_contains(self):
47 s = OrderedSet()
48 self.assertEqual(len(s), 0)
49 s.add(1)
50 self.assertIn(1, s)
51
52 def test_bool(self):
53 # Refs #23664
54 s = OrderedSet()
55 self.assertFalse(s)
56 s.add(1)
57 self.assertTrue(s)
58
59 def test_len(self):
60 s = OrderedSet()
61 self.assertEqual(len(s), 0)
62 s.add(1)
63 s.add(2)
64 s.add(2)
65 self.assertEqual(len(s), 2)
66
67 def test_repr(self):
68 self.assertEqual(repr(OrderedSet()), "OrderedSet()")
69 self.assertEqual(repr(OrderedSet([2, 3, 2, 1])), "OrderedSet([2, 3, 1])")
70
71
72 class MultiValueDictTests(SimpleTestCase):
73 def test_repr(self):
74 d = MultiValueDict({"key": "value"})
75 self.assertEqual(repr(d), "<MultiValueDict: {'key': 'value'}>")
76
77 def test_multivaluedict(self):
78 d = MultiValueDict(
79 {"name": ["Adrian", "Simon"], "position": ["Developer"], "empty": []}
80 )
81 self.assertEqual(d["name"], "Simon")
82 self.assertEqual(d.get("name"), "Simon")
83 self.assertEqual(d.getlist("name"), ["Adrian", "Simon"])
84 self.assertEqual(
85 list(d.items()),
86 [("name", "Simon"), ("position", "Developer"), ("empty", [])],
87 )
88 self.assertEqual(
89 list(d.lists()),
90 [("name", ["Adrian", "Simon"]), ("position", ["Developer"]), ("empty", [])],
91 )
92 with self.assertRaisesMessage(MultiValueDictKeyError, "'lastname'"):
93 d.__getitem__("lastname")
94 self.assertIsNone(d.get("empty"))
95 self.assertEqual(d.get("empty", "nonexistent"), "nonexistent")
96 self.assertIsNone(d.get("lastname"))
97 self.assertEqual(d.get("lastname", "nonexistent"), "nonexistent")
98 self.assertEqual(d.getlist("lastname"), [])
99 self.assertEqual(
100 d.getlist("doesnotexist", ["Adrian", "Simon"]), ["Adrian", "Simon"]
101 )
102 d.setlist("lastname", ["Holovaty", "Willison"])
103 self.assertEqual(d.getlist("lastname"), ["Holovaty", "Willison"])
104 self.assertEqual(list(d.values()), ["Simon", "Developer", [], "Willison"])
105
106 d.setlistdefault("lastname", ["Doe"])
107 self.assertEqual(d.getlist("lastname"), ["Holovaty", "Willison"])
108 d.setlistdefault("newkey", ["Doe"])
109 self.assertEqual(d.getlist("newkey"), ["Doe"])
110
111 def test_appendlist(self):
112 d = MultiValueDict()
113 d.appendlist("name", "Adrian")
114 d.appendlist("name", "Simon")
115 self.assertEqual(d.getlist("name"), ["Adrian", "Simon"])
116
117 def test_copy(self):
118 for copy_func in [copy.copy, lambda d: d.copy()]:
119 with self.subTest(copy_func):
120 d1 = MultiValueDict({"developers": ["Carl", "Fred"]})
121 self.assertEqual(d1["developers"], "Fred")
122 d2 = copy_func(d1)
123 d2.update({"developers": "Groucho"})
124 self.assertEqual(d2["developers"], "Groucho")
125 self.assertEqual(d1["developers"], "Fred")
126
127 d1 = MultiValueDict({"key": [[]]})
128 self.assertEqual(d1["key"], [])
129 d2 = copy_func(d1)
130 d2["key"].append("Penguin")
131 self.assertEqual(d1["key"], ["Penguin"])
132 self.assertEqual(d2["key"], ["Penguin"])
133
134 def test_deepcopy(self):
135 d1 = MultiValueDict({"a": [[123]]})
136 d2 = copy.copy(d1)
137 d3 = copy.deepcopy(d1)
138 self.assertIs(d1["a"], d2["a"])
139 self.assertIsNot(d1["a"], d3["a"])
140
141 def test_pickle(self):
142 x = MultiValueDict({"a": ["1", "2"], "b": ["3"]})
143 self.assertEqual(x, pickle.loads(pickle.dumps(x)))
144
145 def test_dict_translation(self):
146 mvd = MultiValueDict(
147 {
148 "devs": ["Bob", "Joe"],
149 "pm": ["Rory"],
150 }
151 )
152 d = mvd.dict()
153 self.assertEqual(list(d), list(mvd))
154 for key in mvd:
155 self.assertEqual(d[key], mvd[key])
156
157 self.assertEqual({}, MultiValueDict().dict())
158
159 def test_getlist_doesnt_mutate(self):
160 x = MultiValueDict({"a": ["1", "2"], "b": ["3"]})
161 values = x.getlist("a")
162 values += x.getlist("b")
163 self.assertEqual(x.getlist("a"), ["1", "2"])
164
165 def test_internal_getlist_does_mutate(self):
166 x = MultiValueDict({"a": ["1", "2"], "b": ["3"]})
167 values = x._getlist("a")
168 values += x._getlist("b")
169 self.assertEqual(x._getlist("a"), ["1", "2", "3"])
170
171 def test_getlist_default(self):
172 x = MultiValueDict({"a": [1]})
173 MISSING = object()
174 values = x.getlist("b", default=MISSING)
175 self.assertIs(values, MISSING)
176
177 def test_getlist_none_empty_values(self):
178 x = MultiValueDict({"a": None, "b": []})
179 self.assertIsNone(x.getlist("a"))
180 self.assertEqual(x.getlist("b"), [])
181
182 def test_setitem(self):
183 x = MultiValueDict({"a": [1, 2]})
184 x["a"] = 3
185 self.assertEqual(list(x.lists()), [("a", [3])])
186
187 def test_setdefault(self):
188 x = MultiValueDict({"a": [1, 2]})
189 a = x.setdefault("a", 3)
190 b = x.setdefault("b", 3)
191 self.assertEqual(a, 2)
192 self.assertEqual(b, 3)
193 self.assertEqual(list(x.lists()), [("a", [1, 2]), ("b", [3])])
194
195 def test_update_too_many_args(self):
196 x = MultiValueDict({"a": []})
197 msg = "update expected at most 1 argument, got 2"
198 with self.assertRaisesMessage(TypeError, msg):
199 x.update(1, 2)
200
201 def test_update_no_args(self):
202 x = MultiValueDict({"a": []})
203 x.update()
204 self.assertEqual(list(x.lists()), [("a", [])])
205
206 def test_update_dict_arg(self):
207 x = MultiValueDict({"a": [1], "b": [2], "c": [3]})
208 x.update({"a": 4, "b": 5})
209 self.assertEqual(list(x.lists()), [("a", [1, 4]), ("b", [2, 5]), ("c", [3])])
210
211 def test_update_multivaluedict_arg(self):
212 x = MultiValueDict({"a": [1], "b": [2], "c": [3]})
213 x.update(MultiValueDict({"a": [4], "b": [5]}))
214 self.assertEqual(list(x.lists()), [("a", [1, 4]), ("b", [2, 5]), ("c", [3])])
215
216 def test_update_kwargs(self):
217 x = MultiValueDict({"a": [1], "b": [2], "c": [3]})
218 x.update(a=4, b=5)
219 self.assertEqual(list(x.lists()), [("a", [1, 4]), ("b", [2, 5]), ("c", [3])])
220
221 def test_update_with_empty_iterable(self):
222 for value in ["", b"", (), [], set(), {}]:
223 d = MultiValueDict()
224 d.update(value)
225 self.assertEqual(d, MultiValueDict())
226
227 def test_update_with_iterable_of_pairs(self):
228 for value in [(("a", 1),), [("a", 1)], {("a", 1)}]:
229 d = MultiValueDict()
230 d.update(value)
231 self.assertEqual(d, MultiValueDict({"a": [1]}))
232
233 def test_update_raises_correct_exceptions(self):
234 # MultiValueDict.update() raises equivalent exceptions to
235 # dict.update().
236 # Non-iterable values raise TypeError.
237 for value in [None, True, False, 123, 123.45]:
238 with self.subTest(value), self.assertRaises(TypeError):
239 MultiValueDict().update(value)
240 # Iterables of objects that cannot be unpacked raise TypeError.
241 for value in [b"123", b"abc", (1, 2, 3), [1, 2, 3], {1, 2, 3}]:
242 with self.subTest(value), self.assertRaises(TypeError):
243 MultiValueDict().update(value)
244 # Iterables of unpackable objects with incorrect number of items raise
245 # ValueError.
246 for value in ["123", "abc", ("a", "b", "c"), ["a", "b", "c"], {"a", "b", "c"}]:
247 with self.subTest(value), self.assertRaises(ValueError):
248 MultiValueDict().update(value)
249
250
251 class ImmutableListTests(SimpleTestCase):
252 def test_sort(self):
253 d = ImmutableList(range(10))
254
255 # AttributeError: ImmutableList object is immutable.
256 with self.assertRaisesMessage(
257 AttributeError, "ImmutableList object is immutable."
258 ):
259 d.sort()
260
261 self.assertEqual(repr(d), "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)")
262
263 def test_custom_warning(self):
264 d = ImmutableList(range(10), warning="Object is immutable!")
265
266 self.assertEqual(d[1], 1)
267
268 # AttributeError: Object is immutable!
269 with self.assertRaisesMessage(AttributeError, "Object is immutable!"):
270 d.__setitem__(1, "test")
271
272
273 class DictWrapperTests(SimpleTestCase):
274 def test_dictwrapper(self):
275 def f(x):
276 return "*%s" % x
277
278 d = DictWrapper({"a": "a"}, f, "xx_")
279 self.assertEqual(
280 "Normal: %(a)s. Modified: %(xx_a)s" % d, "Normal: a. Modified: *a"
281 )
282
283
284 class CaseInsensitiveMappingTests(SimpleTestCase):
285 def setUp(self):
286 self.dict1 = CaseInsensitiveMapping(
287 {
288 "Accept": "application/json",
289 "content-type": "text/html",
290 }
291 )
292
293 def test_create_with_invalid_values(self):
294 msg = "dictionary update sequence element #1 has length 4; 2 is required"
295 with self.assertRaisesMessage(ValueError, msg):
296 CaseInsensitiveMapping([("Key1", "Val1"), "Key2"])
297
298 def test_create_with_invalid_key(self):
299 msg = "Element key 1 invalid, only strings are allowed"
300 with self.assertRaisesMessage(ValueError, msg):
301 CaseInsensitiveMapping([(1, "2")])
302
303 def test_list(self):
304 self.assertEqual(list(self.dict1), ["Accept", "content-type"])
305
306 def test_dict(self):
307 self.assertEqual(
308 dict(self.dict1),
309 {"Accept": "application/json", "content-type": "text/html"},
310 )
311
312 def test_repr(self):
313 dict1 = CaseInsensitiveMapping({"Accept": "application/json"})
314 dict2 = CaseInsensitiveMapping({"content-type": "text/html"})
315 self.assertEqual(repr(dict1), repr({"Accept": "application/json"}))
316 self.assertEqual(repr(dict2), repr({"content-type": "text/html"}))
317
318 def test_str(self):
319 dict1 = CaseInsensitiveMapping({"Accept": "application/json"})
320 dict2 = CaseInsensitiveMapping({"content-type": "text/html"})
321 self.assertEqual(str(dict1), str({"Accept": "application/json"}))
322 self.assertEqual(str(dict2), str({"content-type": "text/html"}))
323
324 def test_equal(self):
325 self.assertEqual(
326 self.dict1, {"Accept": "application/json", "content-type": "text/html"}
327 )
328 self.assertNotEqual(
329 self.dict1, {"accept": "application/jso", "Content-Type": "text/html"}
330 )
331 self.assertNotEqual(self.dict1, "string")
332
333 def test_items(self):
334 other = {"Accept": "application/json", "content-type": "text/html"}
335 self.assertEqual(sorted(self.dict1.items()), sorted(other.items()))
336
337 def test_copy(self):
338 copy = self.dict1.copy()
339 self.assertIs(copy, self.dict1)
340 self.assertEqual(copy, self.dict1)
341
342 def test_getitem(self):
343 self.assertEqual(self.dict1["Accept"], "application/json")
344 self.assertEqual(self.dict1["accept"], "application/json")
345 self.assertEqual(self.dict1["aCCept"], "application/json")
346 self.assertEqual(self.dict1["content-type"], "text/html")
347 self.assertEqual(self.dict1["Content-Type"], "text/html")
348 self.assertEqual(self.dict1["Content-type"], "text/html")
349
350 def test_in(self):
351 self.assertIn("Accept", self.dict1)
352 self.assertIn("accept", self.dict1)
353 self.assertIn("aCCept", self.dict1)
354 self.assertIn("content-type", self.dict1)
355 self.assertIn("Content-Type", self.dict1)
356
357 def test_del(self):
358 self.assertIn("Accept", self.dict1)
359 msg = "'CaseInsensitiveMapping' object does not support item deletion"
360 with self.assertRaisesMessage(TypeError, msg):
361 del self.dict1["Accept"]
362 self.assertIn("Accept", self.dict1)
363
364 def test_set(self):
365 self.assertEqual(len(self.dict1), 2)
366 msg = "'CaseInsensitiveMapping' object does not support item assignment"
367 with self.assertRaisesMessage(TypeError, msg):
368 self.dict1["New Key"] = 1
369 self.assertEqual(len(self.dict1), 2)