Debian Codegraph @

tests/utils_tests/test_functional.py

raw
1 from django.test import SimpleTestCase
2 from django.utils.functional import cached_property, classproperty, lazy
3 from django.utils.version import PY312
4
5
6 class FunctionalTests(SimpleTestCase):
7 def test_lazy(self):
8 t = lazy(lambda: tuple(range(3)), list, tuple)
9 for a, b in zip(t(), range(3)):
10 self.assertEqual(a, b)
11
12 def test_lazy_base_class(self):
13 """lazy also finds base class methods in the proxy object"""
14
15 class Base:
16 def base_method(self):
17 pass
18
19 class Klazz(Base):
20 pass
21
22 t = lazy(lambda: Klazz(), Klazz)()
23 self.assertIn("base_method", dir(t))
24
25 def test_lazy_base_class_override(self):
26 """lazy finds the correct (overridden) method implementation"""
27
28 class Base:
29 def method(self):
30 return "Base"
31
32 class Klazz(Base):
33 def method(self):
34 return "Klazz"
35
36 t = lazy(lambda: Klazz(), Base)()
37 self.assertEqual(t.method(), "Klazz")
38
39 def test_lazy_object_to_string(self):
40 class Klazz:
41 def __str__(self):
42 return "Î am ā Ǩlâzz."
43
44 def __bytes__(self):
45 return b"\xc3\x8e am \xc4\x81 binary \xc7\xa8l\xc3\xa2zz."
46
47 t = lazy(lambda: Klazz(), Klazz)()
48 self.assertEqual(str(t), "Î am ā Ǩlâzz.")
49 self.assertEqual(bytes(t), b"\xc3\x8e am \xc4\x81 binary \xc7\xa8l\xc3\xa2zz.")
50
51 def assertCachedPropertyWorks(self, attr, Class):
52 with self.subTest(attr=attr):
53
54 def get(source):
55 return getattr(source, attr)
56
57 obj = Class()
58
59 class SubClass(Class):
60 pass
61
62 subobj = SubClass()
63 # Docstring is preserved.
64 self.assertEqual(get(Class).__doc__, "Here is the docstring...")
65 self.assertEqual(get(SubClass).__doc__, "Here is the docstring...")
66 # It's cached.
67 self.assertEqual(get(obj), get(obj))
68 self.assertEqual(get(subobj), get(subobj))
69 # The correct value is returned.
70 self.assertEqual(get(obj)[0], 1)
71 self.assertEqual(get(subobj)[0], 1)
72 # State isn't shared between instances.
73 obj2 = Class()
74 subobj2 = SubClass()
75 self.assertNotEqual(get(obj), get(obj2))
76 self.assertNotEqual(get(subobj), get(subobj2))
77 # It behaves like a property when there's no instance.
78 self.assertIsInstance(get(Class), cached_property)
79 self.assertIsInstance(get(SubClass), cached_property)
80 # 'other_value' doesn't become a property.
81 self.assertTrue(callable(obj.other_value))
82 self.assertTrue(callable(subobj.other_value))
83
84 def test_cached_property(self):
85 """cached_property caches its value and behaves like a property."""
86
87 class Class:
88 @cached_property
89 def value(self):
90 """Here is the docstring..."""
91 return 1, object()
92
93 @cached_property
94 def __foo__(self):
95 """Here is the docstring..."""
96 return 1, object()
97
98 def other_value(self):
99 """Here is the docstring..."""
100 return 1, object()
101
102 other = cached_property(other_value)
103
104 attrs = ["value", "other", "__foo__"]
105 for attr in attrs:
106 self.assertCachedPropertyWorks(attr, Class)
107
108 def test_cached_property_auto_name(self):
109 """
110 cached_property caches its value and behaves like a property
111 on mangled methods or when the name kwarg isn't set.
112 """
113
114 class Class:
115 @cached_property
116 def __value(self):
117 """Here is the docstring..."""
118 return 1, object()
119
120 def other_value(self):
121 """Here is the docstring..."""
122 return 1, object()
123
124 other = cached_property(other_value)
125
126 attrs = ["_Class__value", "other"]
127 for attr in attrs:
128 self.assertCachedPropertyWorks(attr, Class)
129
130 def test_cached_property_reuse_different_names(self):
131 """Disallow this case because the decorated function wouldn't be cached."""
132 type_msg = (
133 "Cannot assign the same cached_property to two different names ('a' and "
134 "'b')."
135 )
136 if PY312:
137 error_type = TypeError
138 msg = type_msg
139 else:
140 error_type = RuntimeError
141 msg = "Error calling __set_name__"
142
143 with self.assertRaisesMessage(error_type, msg) as ctx:
144
145 class ReusedCachedProperty:
146 @cached_property
147 def a(self):
148 pass
149
150 b = a
151
152 if not PY312:
153 self.assertEqual(str(ctx.exception.__context__), str(TypeError(type_msg)))
154
155 def test_cached_property_reuse_same_name(self):
156 """
157 Reusing a cached_property on different classes under the same name is
158 allowed.
159 """
160 counter = 0
161
162 @cached_property
163 def _cp(_self):
164 nonlocal counter
165 counter += 1
166 return counter
167
168 class A:
169 cp = _cp
170
171 class B:
172 cp = _cp
173
174 a = A()
175 b = B()
176 self.assertEqual(a.cp, 1)
177 self.assertEqual(b.cp, 2)
178 self.assertEqual(a.cp, 1)
179
180 def test_cached_property_set_name_not_called(self):
181 cp = cached_property(lambda s: None)
182
183 class Foo:
184 pass
185
186 Foo.cp = cp
187 msg = (
188 "Cannot use cached_property instance without calling __set_name__() on it."
189 )
190 with self.assertRaisesMessage(TypeError, msg):
191 Foo().cp
192
193 def test_lazy_add_int(self):
194 lazy_4 = lazy(lambda: 4, int)
195 lazy_5 = lazy(lambda: 5, int)
196 self.assertEqual(4 + lazy_5(), 9)
197 self.assertEqual(lazy_4() + 5, 9)
198 self.assertEqual(lazy_4() + lazy_5(), 9)
199
200 def test_lazy_add_list(self):
201 lazy_4 = lazy(lambda: [4], list)
202 lazy_5 = lazy(lambda: [5], list)
203 self.assertEqual([4] + lazy_5(), [4, 5])
204 self.assertEqual(lazy_4() + [5], [4, 5])
205 self.assertEqual(lazy_4() + lazy_5(), [4, 5])
206
207 def test_lazy_add_str(self):
208 lazy_a = lazy(lambda: "a", str)
209 lazy_b = lazy(lambda: "b", str)
210 self.assertEqual("a" + lazy_b(), "ab")
211 self.assertEqual(lazy_a() + "b", "ab")
212 self.assertEqual(lazy_a() + lazy_b(), "ab")
213
214 def test_lazy_mod_int(self):
215 lazy_4 = lazy(lambda: 4, int)
216 lazy_5 = lazy(lambda: 5, int)
217 self.assertEqual(4 % lazy_5(), 4)
218 self.assertEqual(lazy_4() % 5, 4)
219 self.assertEqual(lazy_4() % lazy_5(), 4)
220
221 def test_lazy_mod_str(self):
222 lazy_a = lazy(lambda: "a%s", str)
223 lazy_b = lazy(lambda: "b", str)
224 self.assertEqual("a%s" % lazy_b(), "ab")
225 self.assertEqual(lazy_a() % "b", "ab")
226 self.assertEqual(lazy_a() % lazy_b(), "ab")
227
228 def test_lazy_mul_int(self):
229 lazy_4 = lazy(lambda: 4, int)
230 lazy_5 = lazy(lambda: 5, int)
231 self.assertEqual(4 * lazy_5(), 20)
232 self.assertEqual(lazy_4() * 5, 20)
233 self.assertEqual(lazy_4() * lazy_5(), 20)
234
235 def test_lazy_mul_list(self):
236 lazy_4 = lazy(lambda: [4], list)
237 lazy_5 = lazy(lambda: 5, int)
238 self.assertEqual([4] * lazy_5(), [4, 4, 4, 4, 4])
239 self.assertEqual(lazy_4() * 5, [4, 4, 4, 4, 4])
240 self.assertEqual(lazy_4() * lazy_5(), [4, 4, 4, 4, 4])
241
242 def test_lazy_mul_str(self):
243 lazy_a = lazy(lambda: "a", str)
244 lazy_5 = lazy(lambda: 5, int)
245 self.assertEqual("a" * lazy_5(), "aaaaa")
246 self.assertEqual(lazy_a() * 5, "aaaaa")
247 self.assertEqual(lazy_a() * lazy_5(), "aaaaa")
248
249 def test_lazy_format(self):
250 class QuotedString(str):
251 def __format__(self, format_spec):
252 value = super().__format__(format_spec)
253 return f"“{value}”"
254
255 lazy_f = lazy(lambda: QuotedString("Hello!"), QuotedString)
256 self.assertEqual(format(lazy_f(), ""), "“Hello!”")
257 f = lazy_f()
258 self.assertEqual(f"I said, {f}", "I said, “Hello!”")
259
260 def test_lazy_equality(self):
261 """
262 == and != work correctly for Promises.
263 """
264 lazy_a = lazy(lambda: 4, int)
265 lazy_b = lazy(lambda: 4, int)
266 lazy_c = lazy(lambda: 5, int)
267
268 self.assertEqual(lazy_a(), lazy_b())
269 self.assertNotEqual(lazy_b(), lazy_c())
270
271 def test_lazy_repr_text(self):
272 original_object = "Lazy translation text"
273 lazy_obj = lazy(lambda: original_object, str)
274 self.assertEqual(repr(original_object), repr(lazy_obj()))
275
276 def test_lazy_repr_int(self):
277 original_object = 15
278 lazy_obj = lazy(lambda: original_object, int)
279 self.assertEqual(repr(original_object), repr(lazy_obj()))
280
281 def test_lazy_repr_bytes(self):
282 original_object = b"J\xc3\xbcst a str\xc3\xadng"
283 lazy_obj = lazy(lambda: original_object, bytes)
284 self.assertEqual(repr(original_object), repr(lazy_obj()))
285
286 def test_lazy_regular_method(self):
287 original_object = 15
288 lazy_obj = lazy(lambda: original_object, int)
289 self.assertEqual(original_object.bit_length(), lazy_obj().bit_length())
290
291 def test_lazy_bytes_and_str_result_classes(self):
292 lazy_obj = lazy(lambda: "test", str, bytes)
293 self.assertEqual(str(lazy_obj()), "test")
294
295 def test_lazy_str_cast_mixed_result_types(self):
296 lazy_value = lazy(lambda: [1], str, list)()
297 self.assertEqual(str(lazy_value), "[1]")
298
299 def test_lazy_str_cast_mixed_bytes_result_types(self):
300 lazy_value = lazy(lambda: [1], bytes, list)()
301 self.assertEqual(str(lazy_value), "[1]")
302
303 def test_classproperty_getter(self):
304 class Foo:
305 foo_attr = 123
306
307 def __init__(self):
308 self.foo_attr = 456
309
310 @classproperty
311 def foo(cls):
312 return cls.foo_attr
313
314 class Bar:
315 bar = classproperty()
316
317 @bar.getter
318 def bar(cls):
319 return 123
320
321 self.assertEqual(Foo.foo, 123)
322 self.assertEqual(Foo().foo, 123)
323 self.assertEqual(Bar.bar, 123)
324 self.assertEqual(Bar().bar, 123)
325
326 def test_classproperty_override_getter(self):
327 class Foo:
328 @classproperty
329 def foo(cls):
330 return 123
331
332 @foo.getter
333 def foo(cls):
334 return 456
335
336 self.assertEqual(Foo.foo, 456)
337 self.assertEqual(Foo().foo, 456)