Debian Codegraph @

tests/urlpatterns/tests.py

raw
1 import string
2 import uuid
3
4 from django.core.exceptions import ImproperlyConfigured
5 from django.test import SimpleTestCase
6 from django.test.utils import override_settings
7 from django.urls import (
8 NoReverseMatch,
9 Resolver404,
10 path,
11 re_path,
12 register_converter,
13 resolve,
14 reverse,
15 )
16 from django.urls.converters import REGISTERED_CONVERTERS, IntConverter
17 from django.utils.deprecation import RemovedInDjango60Warning
18 from django.views import View
19
20 from .converters import Base64Converter, DynamicConverter
21 from .views import empty_view
22
23 included_kwargs = {"base": b"hello", "value": b"world"}
24 converter_test_data = (
25 # ('url', ('url_name', 'app_name', {kwargs})),
26 # aGVsbG8= is 'hello' encoded in base64.
27 ("/base64/aGVsbG8=/", ("base64", "", {"value": b"hello"})),
28 (
29 "/base64/aGVsbG8=/subpatterns/d29ybGQ=/",
30 ("subpattern-base64", "", included_kwargs),
31 ),
32 (
33 "/base64/aGVsbG8=/namespaced/d29ybGQ=/",
34 ("subpattern-base64", "namespaced-base64", included_kwargs),
35 ),
36 )
37
38
39 @override_settings(ROOT_URLCONF="urlpatterns.path_urls")
40 class SimplifiedURLTests(SimpleTestCase):
41 def test_path_lookup_without_parameters(self):
42 match = resolve("/articles/2003/")
43 self.assertEqual(match.url_name, "articles-2003")
44 self.assertEqual(match.args, ())
45 self.assertEqual(match.kwargs, {})
46 self.assertEqual(match.route, "articles/2003/")
47 self.assertEqual(match.captured_kwargs, {})
48 self.assertEqual(match.extra_kwargs, {})
49
50 def test_path_lookup_with_typed_parameters(self):
51 match = resolve("/articles/2015/")
52 self.assertEqual(match.url_name, "articles-year")
53 self.assertEqual(match.args, ())
54 self.assertEqual(match.kwargs, {"year": 2015})
55 self.assertEqual(match.route, "articles/<int:year>/")
56 self.assertEqual(match.captured_kwargs, {"year": 2015})
57 self.assertEqual(match.extra_kwargs, {})
58
59 def test_path_lookup_with_multiple_parameters(self):
60 match = resolve("/articles/2015/04/12/")
61 self.assertEqual(match.url_name, "articles-year-month-day")
62 self.assertEqual(match.args, ())
63 self.assertEqual(match.kwargs, {"year": 2015, "month": 4, "day": 12})
64 self.assertEqual(match.route, "articles/<int:year>/<int:month>/<int:day>/")
65 self.assertEqual(match.captured_kwargs, {"year": 2015, "month": 4, "day": 12})
66 self.assertEqual(match.extra_kwargs, {})
67
68 def test_path_lookup_with_multiple_parameters_and_extra_kwarg(self):
69 match = resolve("/books/2015/04/12/")
70 self.assertEqual(match.url_name, "books-year-month-day")
71 self.assertEqual(match.args, ())
72 self.assertEqual(
73 match.kwargs, {"year": 2015, "month": 4, "day": 12, "extra": True}
74 )
75 self.assertEqual(match.route, "books/<int:year>/<int:month>/<int:day>/")
76 self.assertEqual(match.captured_kwargs, {"year": 2015, "month": 4, "day": 12})
77 self.assertEqual(match.extra_kwargs, {"extra": True})
78
79 def test_path_lookup_with_extra_kwarg(self):
80 match = resolve("/books/2007/")
81 self.assertEqual(match.url_name, "books-2007")
82 self.assertEqual(match.args, ())
83 self.assertEqual(match.kwargs, {"extra": True})
84 self.assertEqual(match.route, "books/2007/")
85 self.assertEqual(match.captured_kwargs, {})
86 self.assertEqual(match.extra_kwargs, {"extra": True})
87
88 def test_two_variable_at_start_of_path_pattern(self):
89 match = resolve("/en/foo/")
90 self.assertEqual(match.url_name, "lang-and-path")
91 self.assertEqual(match.kwargs, {"lang": "en", "url": "foo"})
92 self.assertEqual(match.route, "<lang>/<path:url>/")
93 self.assertEqual(match.captured_kwargs, {"lang": "en", "url": "foo"})
94 self.assertEqual(match.extra_kwargs, {})
95
96 def test_re_path(self):
97 match = resolve("/regex/1/")
98 self.assertEqual(match.url_name, "regex")
99 self.assertEqual(match.kwargs, {"pk": "1"})
100 self.assertEqual(match.route, "^regex/(?P<pk>[0-9]+)/$")
101 self.assertEqual(match.captured_kwargs, {"pk": "1"})
102 self.assertEqual(match.extra_kwargs, {})
103
104 def test_re_path_with_optional_parameter(self):
105 for url, kwargs in (
106 ("/regex_optional/1/2/", {"arg1": "1", "arg2": "2"}),
107 ("/regex_optional/1/", {"arg1": "1"}),
108 ):
109 with self.subTest(url=url):
110 match = resolve(url)
111 self.assertEqual(match.url_name, "regex_optional")
112 self.assertEqual(match.kwargs, kwargs)
113 self.assertEqual(
114 match.route,
115 r"^regex_optional/(?P<arg1>\d+)/(?:(?P<arg2>\d+)/)?",
116 )
117 self.assertEqual(match.captured_kwargs, kwargs)
118 self.assertEqual(match.extra_kwargs, {})
119
120 def test_re_path_with_missing_optional_parameter(self):
121 match = resolve("/regex_only_optional/")
122 self.assertEqual(match.url_name, "regex_only_optional")
123 self.assertEqual(match.kwargs, {})
124 self.assertEqual(match.args, ())
125 self.assertEqual(
126 match.route,
127 r"^regex_only_optional/(?:(?P<arg1>\d+)/)?",
128 )
129 self.assertEqual(match.captured_kwargs, {})
130 self.assertEqual(match.extra_kwargs, {})
131
132 def test_path_lookup_with_inclusion(self):
133 match = resolve("/included_urls/extra/something/")
134 self.assertEqual(match.url_name, "inner-extra")
135 self.assertEqual(match.route, "included_urls/extra/<extra>/")
136
137 def test_path_lookup_with_empty_string_inclusion(self):
138 match = resolve("/more/99/")
139 self.assertEqual(match.url_name, "inner-more")
140 self.assertEqual(match.route, r"^more/(?P<extra>\w+)/$")
141 self.assertEqual(match.kwargs, {"extra": "99", "sub-extra": True})
142 self.assertEqual(match.captured_kwargs, {"extra": "99"})
143 self.assertEqual(match.extra_kwargs, {"sub-extra": True})
144
145 def test_path_lookup_with_double_inclusion(self):
146 match = resolve("/included_urls/more/some_value/")
147 self.assertEqual(match.url_name, "inner-more")
148 self.assertEqual(match.route, r"included_urls/more/(?P<extra>\w+)/$")
149
150 def test_path_reverse_without_parameter(self):
151 url = reverse("articles-2003")
152 self.assertEqual(url, "/articles/2003/")
153
154 def test_path_reverse_with_parameter(self):
155 url = reverse(
156 "articles-year-month-day", kwargs={"year": 2015, "month": 4, "day": 12}
157 )
158 self.assertEqual(url, "/articles/2015/4/12/")
159
160 @override_settings(ROOT_URLCONF="urlpatterns.path_base64_urls")
161 def test_converter_resolve(self):
162 for url, (url_name, app_name, kwargs) in converter_test_data:
163 with self.subTest(url=url):
164 match = resolve(url)
165 self.assertEqual(match.url_name, url_name)
166 self.assertEqual(match.app_name, app_name)
167 self.assertEqual(match.kwargs, kwargs)
168
169 @override_settings(ROOT_URLCONF="urlpatterns.path_base64_urls")
170 def test_converter_reverse(self):
171 for expected, (url_name, app_name, kwargs) in converter_test_data:
172 if app_name:
173 url_name = "%s:%s" % (app_name, url_name)
174 with self.subTest(url=url_name):
175 url = reverse(url_name, kwargs=kwargs)
176 self.assertEqual(url, expected)
177
178 @override_settings(ROOT_URLCONF="urlpatterns.path_base64_urls")
179 def test_converter_reverse_with_second_layer_instance_namespace(self):
180 kwargs = included_kwargs.copy()
181 kwargs["last_value"] = b"world"
182 url = reverse("instance-ns-base64:subsubpattern-base64", kwargs=kwargs)
183 self.assertEqual(url, "/base64/aGVsbG8=/subpatterns/d29ybGQ=/d29ybGQ=/")
184
185 def test_path_inclusion_is_matchable(self):
186 match = resolve("/included_urls/extra/something/")
187 self.assertEqual(match.url_name, "inner-extra")
188 self.assertEqual(match.kwargs, {"extra": "something"})
189
190 def test_path_inclusion_is_reversible(self):
191 url = reverse("inner-extra", kwargs={"extra": "something"})
192 self.assertEqual(url, "/included_urls/extra/something/")
193
194 def test_invalid_kwargs(self):
195 msg = "kwargs argument must be a dict, but got str."
196 with self.assertRaisesMessage(TypeError, msg):
197 path("hello/", empty_view, "name")
198 with self.assertRaisesMessage(TypeError, msg):
199 re_path("^hello/$", empty_view, "name")
200
201 def test_invalid_converter(self):
202 msg = "URL route 'foo/<nonexistent:var>/' uses invalid converter 'nonexistent'."
203 with self.assertRaisesMessage(ImproperlyConfigured, msg):
204 path("foo/<nonexistent:var>/", empty_view)
205
206 def test_warning_override_default_converter(self):
207 # RemovedInDjango60Warning: when the deprecation ends, replace with
208 # msg = "Converter 'int' is already registered."
209 # with self.assertRaisesMessage(ValueError, msg):
210 msg = (
211 "Converter 'int' is already registered. Support for overriding registered "
212 "converters is deprecated and will be removed in Django 6.0."
213 )
214 try:
215 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
216 register_converter(IntConverter, "int")
217 finally:
218 REGISTERED_CONVERTERS.pop("int", None)
219 self.assertEqual(ctx.filename, __file__)
220
221 def test_warning_override_converter(self):
222 # RemovedInDjango60Warning: when the deprecation ends, replace with
223 # msg = "Converter 'base64' is already registered."
224 # with self.assertRaisesMessage(ValueError, msg):
225 msg = (
226 "Converter 'base64' is already registered. Support for overriding "
227 "registered converters is deprecated and will be removed in Django 6.0."
228 )
229 try:
230 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
231 register_converter(Base64Converter, "base64")
232 register_converter(Base64Converter, "base64")
233 finally:
234 REGISTERED_CONVERTERS.pop("base64", None)
235 self.assertEqual(ctx.filename, __file__)
236
237 def test_invalid_view(self):
238 msg = "view must be a callable or a list/tuple in the case of include()."
239 with self.assertRaisesMessage(TypeError, msg):
240 path("articles/", "invalid_view")
241
242 def test_invalid_view_instance(self):
243 class EmptyCBV(View):
244 pass
245
246 msg = "view must be a callable, pass EmptyCBV.as_view(), not EmptyCBV()."
247 with self.assertRaisesMessage(TypeError, msg):
248 path("foo", EmptyCBV())
249
250 def test_whitespace_in_route(self):
251 msg = "URL route %r cannot contain whitespace in angle brackets <…>"
252 for whitespace in string.whitespace:
253 with self.subTest(repr(whitespace)):
254 route = "space/<int:num>/extra/<str:%stest>" % whitespace
255 with self.assertRaisesMessage(ImproperlyConfigured, msg % route):
256 path(route, empty_view)
257 # Whitespaces are valid in paths.
258 p = path("space%s/<int:num>/" % string.whitespace, empty_view)
259 match = p.resolve("space%s/1/" % string.whitespace)
260 self.assertEqual(match.kwargs, {"num": 1})
261
262 def test_path_trailing_newlines(self):
263 tests = [
264 "/articles/2003/\n",
265 "/articles/2010/\n",
266 "/en/foo/\n",
267 "/included_urls/extra/\n",
268 "/regex/1/\n",
269 "/users/1/\n",
270 ]
271 for url in tests:
272 with self.subTest(url=url), self.assertRaises(Resolver404):
273 resolve(url)
274
275
276 @override_settings(ROOT_URLCONF="urlpatterns.converter_urls")
277 class ConverterTests(SimpleTestCase):
278 def test_matching_urls(self):
279 def no_converter(x):
280 return x
281
282 test_data = (
283 ("int", {"0", "1", "01", 1234567890}, int),
284 ("str", {"abcxyz"}, no_converter),
285 ("path", {"allows.ANY*characters"}, no_converter),
286 ("slug", {"abcxyz-ABCXYZ_01234567890"}, no_converter),
287 ("uuid", {"39da9369-838e-4750-91a5-f7805cd82839"}, uuid.UUID),
288 )
289 for url_name, url_suffixes, converter in test_data:
290 for url_suffix in url_suffixes:
291 url = "/%s/%s/" % (url_name, url_suffix)
292 with self.subTest(url=url):
293 match = resolve(url)
294 self.assertEqual(match.url_name, url_name)
295 self.assertEqual(match.kwargs, {url_name: converter(url_suffix)})
296 # reverse() works with string parameters.
297 string_kwargs = {url_name: url_suffix}
298 self.assertEqual(reverse(url_name, kwargs=string_kwargs), url)
299 # reverse() also works with native types (int, UUID, etc.).
300 if converter is not no_converter:
301 # The converted value might be different for int (a
302 # leading zero is lost in the conversion).
303 converted_value = match.kwargs[url_name]
304 converted_url = "/%s/%s/" % (url_name, converted_value)
305 self.assertEqual(
306 reverse(url_name, kwargs={url_name: converted_value}),
307 converted_url,
308 )
309
310 def test_nonmatching_urls(self):
311 test_data = (
312 ("int", {"-1", "letters"}),
313 ("str", {"", "/"}),
314 ("path", {""}),
315 ("slug", {"", "stars*notallowed"}),
316 (
317 "uuid",
318 {
319 "",
320 "9da9369-838e-4750-91a5-f7805cd82839",
321 "39da9369-838-4750-91a5-f7805cd82839",
322 "39da9369-838e-475-91a5-f7805cd82839",
323 "39da9369-838e-4750-91a-f7805cd82839",
324 "39da9369-838e-4750-91a5-f7805cd8283",
325 },
326 ),
327 )
328 for url_name, url_suffixes in test_data:
329 for url_suffix in url_suffixes:
330 url = "/%s/%s/" % (url_name, url_suffix)
331 with self.subTest(url=url), self.assertRaises(Resolver404):
332 resolve(url)
333
334
335 @override_settings(ROOT_URLCONF="urlpatterns.path_same_name_urls")
336 class SameNameTests(SimpleTestCase):
337 def test_matching_urls_same_name(self):
338 @DynamicConverter.register_to_url
339 def requires_tiny_int(value):
340 if value > 5:
341 raise ValueError
342 return value
343
344 tests = [
345 (
346 "number_of_args",
347 [
348 ([], {}, "0/"),
349 ([1], {}, "1/1/"),
350 ],
351 ),
352 (
353 "kwargs_names",
354 [
355 ([], {"a": 1}, "a/1/"),
356 ([], {"b": 1}, "b/1/"),
357 ],
358 ),
359 (
360 "converter",
361 [
362 (["a/b"], {}, "path/a/b/"),
363 (["a b"], {}, "str/a%20b/"),
364 (["a-b"], {}, "slug/a-b/"),
365 (["2"], {}, "int/2/"),
366 (
367 ["39da9369-838e-4750-91a5-f7805cd82839"],
368 {},
369 "uuid/39da9369-838e-4750-91a5-f7805cd82839/",
370 ),
371 ],
372 ),
373 (
374 "regex",
375 [
376 (["ABC"], {}, "uppercase/ABC/"),
377 (["abc"], {}, "lowercase/abc/"),
378 ],
379 ),
380 (
381 "converter_to_url",
382 [
383 ([6], {}, "int/6/"),
384 ([1], {}, "tiny_int/1/"),
385 ],
386 ),
387 ]
388 for url_name, cases in tests:
389 for args, kwargs, url_suffix in cases:
390 expected_url = "/%s/%s" % (url_name, url_suffix)
391 with self.subTest(url=expected_url):
392 self.assertEqual(
393 reverse(url_name, args=args, kwargs=kwargs),
394 expected_url,
395 )
396
397
398 class ParameterRestrictionTests(SimpleTestCase):
399 def test_integer_parameter_name_causes_exception(self):
400 msg = (
401 "URL route 'hello/<int:1>/' uses parameter name '1' which isn't "
402 "a valid Python identifier."
403 )
404 with self.assertRaisesMessage(ImproperlyConfigured, msg):
405 path(r"hello/<int:1>/", lambda r: None)
406
407 def test_non_identifier_parameter_name_causes_exception(self):
408 msg = (
409 "URL route 'b/<int:book.id>/' uses parameter name 'book.id' which "
410 "isn't a valid Python identifier."
411 )
412 with self.assertRaisesMessage(ImproperlyConfigured, msg):
413 path(r"b/<int:book.id>/", lambda r: None)
414
415 def test_allows_non_ascii_but_valid_identifiers(self):
416 # \u0394 is "GREEK CAPITAL LETTER DELTA", a valid identifier.
417 p = path("hello/<str:\u0394>/", lambda r: None)
418 match = p.resolve("hello/1/")
419 self.assertEqual(match.kwargs, {"\u0394": "1"})
420
421
422 @override_settings(ROOT_URLCONF="urlpatterns.path_dynamic_urls")
423 class ConversionExceptionTests(SimpleTestCase):
424 """How are errors in Converter.to_python() and to_url() handled?"""
425
426 def test_resolve_value_error_means_no_match(self):
427 @DynamicConverter.register_to_python
428 def raises_value_error(value):
429 raise ValueError()
430
431 with self.assertRaises(Resolver404):
432 resolve("/dynamic/abc/")
433
434 def test_resolve_type_error_propagates(self):
435 @DynamicConverter.register_to_python
436 def raises_type_error(value):
437 raise TypeError("This type error propagates.")
438
439 with self.assertRaisesMessage(TypeError, "This type error propagates."):
440 resolve("/dynamic/abc/")
441
442 def test_reverse_value_error_means_no_match(self):
443 @DynamicConverter.register_to_url
444 def raises_value_error(value):
445 raise ValueError
446
447 with self.assertRaises(NoReverseMatch):
448 reverse("dynamic", kwargs={"value": object()})
449
450 def test_reverse_type_error_propagates(self):
451 @DynamicConverter.register_to_url
452 def raises_type_error(value):
453 raise TypeError("This type error propagates.")
454
455 with self.assertRaisesMessage(TypeError, "This type error propagates."):
456 reverse("dynamic", kwargs={"value": object()})