Debian Codegraph @

tests/test_choices.py

raw
1 from __future__ import annotations
2
3 from typing import TYPE_CHECKING, Generic, TypeVar
4
5 import pytest
6 from django.test import TestCase
7
8 from model_utils import Choices
9
10 T = TypeVar("T")
11
12
13 class ChoicesTestsMixin(Generic[T]):
14
15 STATUS: Choices[T]
16
17 def test_getattr(self) -> None:
18 assert self.STATUS.DRAFT == 'DRAFT'
19
20 def test_len(self) -> None:
21 assert len(self.STATUS) == 2
22
23 def test_repr(self) -> None:
24 assert repr(self.STATUS) == "Choices" + repr((
25 ('DRAFT', 'DRAFT', 'DRAFT'),
26 ('PUBLISHED', 'PUBLISHED', 'PUBLISHED'),
27 ))
28
29 def test_wrong_length_tuple(self) -> None:
30 with pytest.raises(ValueError):
31 Choices(('a',)) # type: ignore[arg-type]
32
33 def test_deepcopy(self) -> None:
34 import copy
35 assert list(self.STATUS) == list(copy.deepcopy(self.STATUS))
36
37 def test_equality(self) -> None:
38 assert self.STATUS == Choices('DRAFT', 'PUBLISHED')
39
40 def test_inequality(self) -> None:
41 assert self.STATUS != ['DRAFT', 'PUBLISHED']
42 assert self.STATUS != Choices('DRAFT')
43
44 def test_composability(self) -> None:
45 assert Choices('DRAFT') + Choices('PUBLISHED') == self.STATUS
46 assert Choices('DRAFT') + ('PUBLISHED',) == self.STATUS
47 assert ('DRAFT',) + Choices('PUBLISHED') == self.STATUS
48
49 def test_option_groups(self) -> None:
50 # Note: The implementation accepts any kind of sequence, but the type system can only
51 # track per-index types for tuples.
52 if TYPE_CHECKING:
53 c = Choices(('group a', ['one', 'two']), ('group b', ('three',)))
54 else:
55 c = Choices(('group a', ['one', 'two']), ['group b', ('three',)])
56 assert list(c) == [
57 ('group a', [('one', 'one'), ('two', 'two')]),
58 ('group b', [('three', 'three')]),
59 ]
60
61
62 class ChoicesTests(TestCase, ChoicesTestsMixin[str]):
63 def setUp(self) -> None:
64 self.STATUS = Choices('DRAFT', 'PUBLISHED')
65
66 def test_indexing(self) -> None:
67 self.assertEqual(self.STATUS['PUBLISHED'], 'PUBLISHED')
68
69 def test_iteration(self) -> None:
70 self.assertEqual(tuple(self.STATUS),
71 (('DRAFT', 'DRAFT'), ('PUBLISHED', 'PUBLISHED')))
72
73 def test_reversed(self) -> None:
74 self.assertEqual(tuple(reversed(self.STATUS)),
75 (('PUBLISHED', 'PUBLISHED'), ('DRAFT', 'DRAFT')))
76
77 def test_contains_value(self) -> None:
78 self.assertTrue('PUBLISHED' in self.STATUS)
79 self.assertTrue('DRAFT' in self.STATUS)
80
81 def test_doesnt_contain_value(self) -> None:
82 self.assertFalse('UNPUBLISHED' in self.STATUS)
83
84
85 class LabelChoicesTests(TestCase, ChoicesTestsMixin[str]):
86 def setUp(self) -> None:
87 self.STATUS = Choices(
88 ('DRAFT', 'is draft'),
89 ('PUBLISHED', 'is published'),
90 'DELETED',
91 )
92
93 def test_iteration(self) -> None:
94 self.assertEqual(tuple(self.STATUS), (
95 ('DRAFT', 'is draft'),
96 ('PUBLISHED', 'is published'),
97 ('DELETED', 'DELETED'),
98 ))
99
100 def test_reversed(self) -> None:
101 self.assertEqual(tuple(reversed(self.STATUS)), (
102 ('DELETED', 'DELETED'),
103 ('PUBLISHED', 'is published'),
104 ('DRAFT', 'is draft'),
105 ))
106
107 def test_indexing(self) -> None:
108 self.assertEqual(self.STATUS['PUBLISHED'], 'is published')
109
110 def test_default(self) -> None:
111 self.assertEqual(self.STATUS.DELETED, 'DELETED')
112
113 def test_provided(self) -> None:
114 self.assertEqual(self.STATUS.DRAFT, 'DRAFT')
115
116 def test_len(self) -> None:
117 self.assertEqual(len(self.STATUS), 3)
118
119 def test_equality(self) -> None:
120 self.assertEqual(self.STATUS, Choices(
121 ('DRAFT', 'is draft'),
122 ('PUBLISHED', 'is published'),
123 'DELETED',
124 ))
125
126 def test_inequality(self) -> None:
127 self.assertNotEqual(self.STATUS, [
128 ('DRAFT', 'is draft'),
129 ('PUBLISHED', 'is published'),
130 'DELETED'
131 ])
132 self.assertNotEqual(self.STATUS, Choices('DRAFT'))
133
134 def test_repr(self) -> None:
135 self.assertEqual(repr(self.STATUS), "Choices" + repr((
136 ('DRAFT', 'DRAFT', 'is draft'),
137 ('PUBLISHED', 'PUBLISHED', 'is published'),
138 ('DELETED', 'DELETED', 'DELETED'),
139 )))
140
141 def test_contains_value(self) -> None:
142 self.assertTrue('PUBLISHED' in self.STATUS)
143 self.assertTrue('DRAFT' in self.STATUS)
144 # This should be True, because both the display value
145 # and the internal representation are both DELETED.
146 self.assertTrue('DELETED' in self.STATUS)
147
148 def test_doesnt_contain_value(self) -> None:
149 self.assertFalse('UNPUBLISHED' in self.STATUS)
150
151 def test_doesnt_contain_display_value(self) -> None:
152 self.assertFalse('is draft' in self.STATUS)
153
154 def test_composability(self) -> None:
155 self.assertEqual(
156 Choices(('DRAFT', 'is draft',)) + Choices(('PUBLISHED', 'is published'), 'DELETED'),
157 self.STATUS
158 )
159
160 self.assertEqual(
161 (('DRAFT', 'is draft',),) + Choices(('PUBLISHED', 'is published'), 'DELETED'),
162 self.STATUS
163 )
164
165 self.assertEqual(
166 Choices(('DRAFT', 'is draft',)) + (('PUBLISHED', 'is published'), 'DELETED'),
167 self.STATUS
168 )
169
170 def test_option_groups(self) -> None:
171 if TYPE_CHECKING:
172 c = Choices[int](
173 ('group a', [(1, 'one'), (2, 'two')]),
174 ('group b', ((3, 'three'),))
175 )
176 else:
177 c = Choices(
178 ('group a', [(1, 'one'), (2, 'two')]),
179 ['group b', ((3, 'three'),)]
180 )
181 self.assertEqual(
182 list(c),
183 [
184 ('group a', [(1, 'one'), (2, 'two')]),
185 ('group b', [(3, 'three')]),
186 ],
187 )
188
189
190 class IdentifierChoicesTests(TestCase, ChoicesTestsMixin[int]):
191 def setUp(self) -> None:
192 self.STATUS = Choices(
193 (0, 'DRAFT', 'is draft'),
194 (1, 'PUBLISHED', 'is published'),
195 (2, 'DELETED', 'is deleted'))
196
197 def test_iteration(self) -> None:
198 self.assertEqual(tuple(self.STATUS), (
199 (0, 'is draft'),
200 (1, 'is published'),
201 (2, 'is deleted'),
202 ))
203
204 def test_reversed(self) -> None:
205 self.assertEqual(tuple(reversed(self.STATUS)), (
206 (2, 'is deleted'),
207 (1, 'is published'),
208 (0, 'is draft'),
209 ))
210
211 def test_indexing(self) -> None:
212 self.assertEqual(self.STATUS[1], 'is published')
213
214 def test_getattr(self) -> None:
215 self.assertEqual(self.STATUS.DRAFT, 0)
216
217 def test_len(self) -> None:
218 self.assertEqual(len(self.STATUS), 3)
219
220 def test_repr(self) -> None:
221 self.assertEqual(repr(self.STATUS), "Choices" + repr((
222 (0, 'DRAFT', 'is draft'),
223 (1, 'PUBLISHED', 'is published'),
224 (2, 'DELETED', 'is deleted'),
225 )))
226
227 def test_contains_value(self) -> None:
228 self.assertTrue(0 in self.STATUS)
229 self.assertTrue(1 in self.STATUS)
230 self.assertTrue(2 in self.STATUS)
231
232 def test_doesnt_contain_value(self) -> None:
233 self.assertFalse(3 in self.STATUS)
234
235 def test_doesnt_contain_display_value(self) -> None:
236 self.assertFalse('is draft' in self.STATUS) # type: ignore[operator]
237
238 def test_doesnt_contain_python_attr(self) -> None:
239 self.assertFalse('PUBLISHED' in self.STATUS) # type: ignore[operator]
240
241 def test_equality(self) -> None:
242 self.assertEqual(self.STATUS, Choices(
243 (0, 'DRAFT', 'is draft'),
244 (1, 'PUBLISHED', 'is published'),
245 (2, 'DELETED', 'is deleted')
246 ))
247
248 def test_inequality(self) -> None:
249 self.assertNotEqual(self.STATUS, [
250 (0, 'DRAFT', 'is draft'),
251 (1, 'PUBLISHED', 'is published'),
252 (2, 'DELETED', 'is deleted')
253 ])
254 self.assertNotEqual(self.STATUS, Choices('DRAFT'))
255
256 def test_composability(self) -> None:
257 self.assertEqual(
258 Choices(
259 (0, 'DRAFT', 'is draft'),
260 (1, 'PUBLISHED', 'is published')
261 ) + Choices(
262 (2, 'DELETED', 'is deleted'),
263 ),
264 self.STATUS
265 )
266
267 self.assertEqual(
268 Choices(
269 (0, 'DRAFT', 'is draft'),
270 (1, 'PUBLISHED', 'is published')
271 ) + (
272 (2, 'DELETED', 'is deleted'),
273 ),
274 self.STATUS
275 )
276
277 self.assertEqual(
278 (
279 (0, 'DRAFT', 'is draft'),
280 (1, 'PUBLISHED', 'is published')
281 ) + Choices(
282 (2, 'DELETED', 'is deleted'),
283 ),
284 self.STATUS
285 )
286
287 def test_option_groups(self) -> None:
288 if TYPE_CHECKING:
289 c = Choices[int](
290 ('group a', [(1, 'ONE', 'one'), (2, 'TWO', 'two')]),
291 ('group b', ((3, 'THREE', 'three'),))
292 )
293 else:
294 c = Choices(
295 ('group a', [(1, 'ONE', 'one'), (2, 'TWO', 'two')]),
296 ['group b', ((3, 'THREE', 'three'),)]
297 )
298 self.assertEqual(
299 list(c),
300 [
301 ('group a', [(1, 'one'), (2, 'two')]),
302 ('group b', [(3, 'three')]),
303 ],
304 )
305
306
307 class SubsetChoicesTest(TestCase):
308
309 def setUp(self) -> None:
310 self.choices = Choices[int](
311 (0, 'a', 'A'),
312 (1, 'b', 'B'),
313 )
314
315 def test_nonexistent_identifiers_raise(self) -> None:
316 with self.assertRaises(ValueError):
317 self.choices.subset('a', 'c')
318
319 def test_solo_nonexistent_identifiers_raise(self) -> None:
320 with self.assertRaises(ValueError):
321 self.choices.subset('c')
322
323 def test_empty_subset_passes(self) -> None:
324 subset = self.choices.subset()
325
326 self.assertEqual(subset, Choices())
327
328 def test_subset_returns_correct_subset(self) -> None:
329 subset = self.choices.subset('a')
330
331 self.assertEqual(subset, Choices((0, 'a', 'A')))