| 1 |
""" |
| 2 |
Unit tests for reverse URL lookups. |
| 3 |
""" |
| 4 |
|
| 5 |
import pickle |
| 6 |
import sys |
| 7 |
import threading |
| 8 |
|
| 9 |
from admin_scripts.tests import AdminScriptTestCase |
| 10 |
|
| 11 |
from django.conf import settings |
| 12 |
from django.contrib.auth.models import User |
| 13 |
from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist |
| 14 |
from django.http import ( |
| 15 |
HttpRequest, |
| 16 |
HttpResponsePermanentRedirect, |
| 17 |
HttpResponseRedirect, |
| 18 |
QueryDict, |
| 19 |
) |
| 20 |
from django.shortcuts import redirect |
| 21 |
from django.test import RequestFactory, SimpleTestCase, TestCase, override_settings |
| 22 |
from django.test.utils import override_script_prefix |
| 23 |
from django.urls import ( |
| 24 |
NoReverseMatch, |
| 25 |
Resolver404, |
| 26 |
ResolverMatch, |
| 27 |
URLPattern, |
| 28 |
URLResolver, |
| 29 |
get_callable, |
| 30 |
get_resolver, |
| 31 |
get_urlconf, |
| 32 |
include, |
| 33 |
path, |
| 34 |
re_path, |
| 35 |
resolve, |
| 36 |
reverse, |
| 37 |
reverse_lazy, |
| 38 |
) |
| 39 |
from django.urls.resolvers import RegexPattern |
| 40 |
|
| 41 |
from . import middleware, urlconf_outer, views |
| 42 |
from .utils import URLObject |
| 43 |
from .views import empty_view |
| 44 |
|
| 45 |
resolve_test_data = ( |
| 46 |
# These entries are in the format: |
| 47 |
# (path, url_name, app_name, namespace, view_name, func, args, kwargs) |
| 48 |
# Simple case |
| 49 |
( |
| 50 |
"/normal/42/37/", |
| 51 |
"normal-view", |
| 52 |
"", |
| 53 |
"", |
| 54 |
"normal-view", |
| 55 |
views.empty_view, |
| 56 |
(), |
| 57 |
{"arg1": "42", "arg2": "37"}, |
| 58 |
), |
| 59 |
( |
| 60 |
"/view_class/42/37/", |
| 61 |
"view-class", |
| 62 |
"", |
| 63 |
"", |
| 64 |
"view-class", |
| 65 |
views.view_class_instance, |
| 66 |
(), |
| 67 |
{"arg1": "42", "arg2": "37"}, |
| 68 |
), |
| 69 |
( |
| 70 |
"/included/normal/42/37/", |
| 71 |
"inc-normal-view", |
| 72 |
"included_namespace_urls", |
| 73 |
"included_namespace_urls", |
| 74 |
"included_namespace_urls:inc-normal-view", |
| 75 |
views.empty_view, |
| 76 |
(), |
| 77 |
{"arg1": "42", "arg2": "37"}, |
| 78 |
), |
| 79 |
( |
| 80 |
"/included/view_class/42/37/", |
| 81 |
"inc-view-class", |
| 82 |
"included_namespace_urls", |
| 83 |
"included_namespace_urls", |
| 84 |
"included_namespace_urls:inc-view-class", |
| 85 |
views.view_class_instance, |
| 86 |
(), |
| 87 |
{"arg1": "42", "arg2": "37"}, |
| 88 |
), |
| 89 |
# Unnamed args are dropped if you have *any* kwargs in a pattern |
| 90 |
( |
| 91 |
"/mixed_args/42/37/", |
| 92 |
"mixed-args", |
| 93 |
"", |
| 94 |
"", |
| 95 |
"mixed-args", |
| 96 |
views.empty_view, |
| 97 |
(), |
| 98 |
{"extra": True, "arg2": "37"}, |
| 99 |
), |
| 100 |
( |
| 101 |
"/included/mixed_args/42/37/", |
| 102 |
"inc-mixed-args", |
| 103 |
"included_namespace_urls", |
| 104 |
"included_namespace_urls", |
| 105 |
"included_namespace_urls:inc-mixed-args", |
| 106 |
views.empty_view, |
| 107 |
(), |
| 108 |
{"arg2": "37"}, |
| 109 |
), |
| 110 |
( |
| 111 |
"/included/12/mixed_args/42/37/", |
| 112 |
"inc-mixed-args", |
| 113 |
"included_namespace_urls", |
| 114 |
"included_namespace_urls", |
| 115 |
"included_namespace_urls:inc-mixed-args", |
| 116 |
views.empty_view, |
| 117 |
(), |
| 118 |
{"arg2": "37"}, |
| 119 |
), |
| 120 |
# Unnamed views should have None as the url_name. Regression data for #21157. |
| 121 |
( |
| 122 |
"/unnamed/normal/42/37/", |
| 123 |
None, |
| 124 |
"", |
| 125 |
"", |
| 126 |
"urlpatterns_reverse.views.empty_view", |
| 127 |
views.empty_view, |
| 128 |
(), |
| 129 |
{"arg1": "42", "arg2": "37"}, |
| 130 |
), |
| 131 |
( |
| 132 |
"/unnamed/view_class/42/37/", |
| 133 |
None, |
| 134 |
"", |
| 135 |
"", |
| 136 |
"urlpatterns_reverse.views.ViewClass", |
| 137 |
views.view_class_instance, |
| 138 |
(), |
| 139 |
{"arg1": "42", "arg2": "37"}, |
| 140 |
), |
| 141 |
# If you have no kwargs, you get an args list. |
| 142 |
( |
| 143 |
"/no_kwargs/42/37/", |
| 144 |
"no-kwargs", |
| 145 |
"", |
| 146 |
"", |
| 147 |
"no-kwargs", |
| 148 |
views.empty_view, |
| 149 |
("42", "37"), |
| 150 |
{}, |
| 151 |
), |
| 152 |
( |
| 153 |
"/included/no_kwargs/42/37/", |
| 154 |
"inc-no-kwargs", |
| 155 |
"included_namespace_urls", |
| 156 |
"included_namespace_urls", |
| 157 |
"included_namespace_urls:inc-no-kwargs", |
| 158 |
views.empty_view, |
| 159 |
("42", "37"), |
| 160 |
{}, |
| 161 |
), |
| 162 |
( |
| 163 |
"/included/12/no_kwargs/42/37/", |
| 164 |
"inc-no-kwargs", |
| 165 |
"included_namespace_urls", |
| 166 |
"included_namespace_urls", |
| 167 |
"included_namespace_urls:inc-no-kwargs", |
| 168 |
views.empty_view, |
| 169 |
("12", "42", "37"), |
| 170 |
{}, |
| 171 |
), |
| 172 |
# Namespaces |
| 173 |
( |
| 174 |
"/test1/inner/42/37/", |
| 175 |
"urlobject-view", |
| 176 |
"testapp", |
| 177 |
"test-ns1", |
| 178 |
"test-ns1:urlobject-view", |
| 179 |
views.empty_view, |
| 180 |
(), |
| 181 |
{"arg1": "42", "arg2": "37"}, |
| 182 |
), |
| 183 |
( |
| 184 |
"/included/test3/inner/42/37/", |
| 185 |
"urlobject-view", |
| 186 |
"included_namespace_urls:testapp", |
| 187 |
"included_namespace_urls:test-ns3", |
| 188 |
"included_namespace_urls:test-ns3:urlobject-view", |
| 189 |
views.empty_view, |
| 190 |
(), |
| 191 |
{"arg1": "42", "arg2": "37"}, |
| 192 |
), |
| 193 |
( |
| 194 |
"/ns-included1/normal/42/37/", |
| 195 |
"inc-normal-view", |
| 196 |
"included_namespace_urls", |
| 197 |
"inc-ns1", |
| 198 |
"inc-ns1:inc-normal-view", |
| 199 |
views.empty_view, |
| 200 |
(), |
| 201 |
{"arg1": "42", "arg2": "37"}, |
| 202 |
), |
| 203 |
( |
| 204 |
"/included/test3/inner/42/37/", |
| 205 |
"urlobject-view", |
| 206 |
"included_namespace_urls:testapp", |
| 207 |
"included_namespace_urls:test-ns3", |
| 208 |
"included_namespace_urls:test-ns3:urlobject-view", |
| 209 |
views.empty_view, |
| 210 |
(), |
| 211 |
{"arg1": "42", "arg2": "37"}, |
| 212 |
), |
| 213 |
( |
| 214 |
"/default/inner/42/37/", |
| 215 |
"urlobject-view", |
| 216 |
"testapp", |
| 217 |
"testapp", |
| 218 |
"testapp:urlobject-view", |
| 219 |
views.empty_view, |
| 220 |
(), |
| 221 |
{"arg1": "42", "arg2": "37"}, |
| 222 |
), |
| 223 |
( |
| 224 |
"/other2/inner/42/37/", |
| 225 |
"urlobject-view", |
| 226 |
"nodefault", |
| 227 |
"other-ns2", |
| 228 |
"other-ns2:urlobject-view", |
| 229 |
views.empty_view, |
| 230 |
(), |
| 231 |
{"arg1": "42", "arg2": "37"}, |
| 232 |
), |
| 233 |
( |
| 234 |
"/other1/inner/42/37/", |
| 235 |
"urlobject-view", |
| 236 |
"nodefault", |
| 237 |
"other-ns1", |
| 238 |
"other-ns1:urlobject-view", |
| 239 |
views.empty_view, |
| 240 |
(), |
| 241 |
{"arg1": "42", "arg2": "37"}, |
| 242 |
), |
| 243 |
# Nested namespaces |
| 244 |
( |
| 245 |
"/ns-included1/test3/inner/42/37/", |
| 246 |
"urlobject-view", |
| 247 |
"included_namespace_urls:testapp", |
| 248 |
"inc-ns1:test-ns3", |
| 249 |
"inc-ns1:test-ns3:urlobject-view", |
| 250 |
views.empty_view, |
| 251 |
(), |
| 252 |
{"arg1": "42", "arg2": "37"}, |
| 253 |
), |
| 254 |
( |
| 255 |
"/ns-included1/ns-included4/ns-included2/test3/inner/42/37/", |
| 256 |
"urlobject-view", |
| 257 |
"included_namespace_urls:namespace_urls:included_namespace_urls:testapp", |
| 258 |
"inc-ns1:inc-ns4:inc-ns2:test-ns3", |
| 259 |
"inc-ns1:inc-ns4:inc-ns2:test-ns3:urlobject-view", |
| 260 |
views.empty_view, |
| 261 |
(), |
| 262 |
{"arg1": "42", "arg2": "37"}, |
| 263 |
), |
| 264 |
( |
| 265 |
"/app-included/test3/inner/42/37/", |
| 266 |
"urlobject-view", |
| 267 |
"included_namespace_urls:testapp", |
| 268 |
"inc-app:test-ns3", |
| 269 |
"inc-app:test-ns3:urlobject-view", |
| 270 |
views.empty_view, |
| 271 |
(), |
| 272 |
{"arg1": "42", "arg2": "37"}, |
| 273 |
), |
| 274 |
( |
| 275 |
"/app-included/ns-included4/ns-included2/test3/inner/42/37/", |
| 276 |
"urlobject-view", |
| 277 |
"included_namespace_urls:namespace_urls:included_namespace_urls:testapp", |
| 278 |
"inc-app:inc-ns4:inc-ns2:test-ns3", |
| 279 |
"inc-app:inc-ns4:inc-ns2:test-ns3:urlobject-view", |
| 280 |
views.empty_view, |
| 281 |
(), |
| 282 |
{"arg1": "42", "arg2": "37"}, |
| 283 |
), |
| 284 |
# Namespaces capturing variables |
| 285 |
( |
| 286 |
"/inc70/", |
| 287 |
"inner-nothing", |
| 288 |
"included_urls", |
| 289 |
"inc-ns5", |
| 290 |
"inc-ns5:inner-nothing", |
| 291 |
views.empty_view, |
| 292 |
(), |
| 293 |
{"outer": "70"}, |
| 294 |
), |
| 295 |
( |
| 296 |
"/inc78/extra/foobar/", |
| 297 |
"inner-extra", |
| 298 |
"included_urls", |
| 299 |
"inc-ns5", |
| 300 |
"inc-ns5:inner-extra", |
| 301 |
views.empty_view, |
| 302 |
(), |
| 303 |
{"outer": "78", "extra": "foobar"}, |
| 304 |
), |
| 305 |
) |
| 306 |
|
| 307 |
test_data = ( |
| 308 |
("places", "/places/3/", [3], {}), |
| 309 |
("places", "/places/3/", ["3"], {}), |
| 310 |
("places", NoReverseMatch, ["a"], {}), |
| 311 |
("places", NoReverseMatch, [], {}), |
| 312 |
("places?", "/place/", [], {}), |
| 313 |
("places+", "/places/", [], {}), |
| 314 |
("places*", "/place/", [], {}), |
| 315 |
("places2?", "/", [], {}), |
| 316 |
("places2+", "/places/", [], {}), |
| 317 |
("places2*", "/", [], {}), |
| 318 |
("places3", "/places/4/", [4], {}), |
| 319 |
("places3", "/places/harlem/", ["harlem"], {}), |
| 320 |
("places3", NoReverseMatch, ["harlem64"], {}), |
| 321 |
("places4", "/places/3/", [], {"id": 3}), |
| 322 |
("people", NoReverseMatch, [], {}), |
| 323 |
("people", "/people/adrian/", ["adrian"], {}), |
| 324 |
("people", "/people/adrian/", [], {"name": "adrian"}), |
| 325 |
("people", NoReverseMatch, ["name with spaces"], {}), |
| 326 |
("people", NoReverseMatch, [], {"name": "name with spaces"}), |
| 327 |
("people2", "/people/name/", [], {}), |
| 328 |
("people2a", "/people/name/fred/", ["fred"], {}), |
| 329 |
("people_backref", "/people/nate-nate/", ["nate"], {}), |
| 330 |
("people_backref", "/people/nate-nate/", [], {"name": "nate"}), |
| 331 |
("optional", "/optional/fred/", [], {"name": "fred"}), |
| 332 |
("optional", "/optional/fred/", ["fred"], {}), |
| 333 |
("named_optional", "/optional/1/", [1], {}), |
| 334 |
("named_optional", "/optional/1/", [], {"arg1": 1}), |
| 335 |
("named_optional", "/optional/1/2/", [1, 2], {}), |
| 336 |
("named_optional", "/optional/1/2/", [], {"arg1": 1, "arg2": 2}), |
| 337 |
("named_optional_terminated", "/optional/1/", [1], {}), |
| 338 |
("named_optional_terminated", "/optional/1/", [], {"arg1": 1}), |
| 339 |
("named_optional_terminated", "/optional/1/2/", [1, 2], {}), |
| 340 |
("named_optional_terminated", "/optional/1/2/", [], {"arg1": 1, "arg2": 2}), |
| 341 |
("hardcoded", "/hardcoded/", [], {}), |
| 342 |
("hardcoded2", "/hardcoded/doc.pdf", [], {}), |
| 343 |
("people3", "/people/il/adrian/", [], {"state": "il", "name": "adrian"}), |
| 344 |
("people3", NoReverseMatch, [], {"state": "il"}), |
| 345 |
("people3", NoReverseMatch, [], {"name": "adrian"}), |
| 346 |
("people4", NoReverseMatch, [], {"state": "il", "name": "adrian"}), |
| 347 |
("people6", "/people/il/test/adrian/", ["il/test", "adrian"], {}), |
| 348 |
("people6", "/people//adrian/", ["adrian"], {}), |
| 349 |
("range", "/character_set/a/", [], {}), |
| 350 |
("range2", "/character_set/x/", [], {}), |
| 351 |
("price", "/price/$10/", ["10"], {}), |
| 352 |
("price2", "/price/$10/", ["10"], {}), |
| 353 |
("price3", "/price/$10/", ["10"], {}), |
| 354 |
( |
| 355 |
"product", |
| 356 |
"/product/chocolate+($2.00)/", |
| 357 |
[], |
| 358 |
{"price": "2.00", "product": "chocolate"}, |
| 359 |
), |
| 360 |
("headlines", "/headlines/2007.5.21/", [], {"year": 2007, "month": 5, "day": 21}), |
| 361 |
( |
| 362 |
"windows", |
| 363 |
r"/windows_path/C:%5CDocuments%20and%20Settings%5Cspam/", |
| 364 |
[], |
| 365 |
{"drive_name": "C", "path": r"Documents and Settings\spam"}, |
| 366 |
), |
| 367 |
("special", r"/special_chars/~@+%5C$*%7C/", [r"~@+\$*|"], {}), |
| 368 |
("special", r"/special_chars/some%20resource/", [r"some resource"], {}), |
| 369 |
("special", r"/special_chars/10%25%20complete/", [r"10% complete"], {}), |
| 370 |
("special", r"/special_chars/some%20resource/", [], {"chars": r"some resource"}), |
| 371 |
("special", r"/special_chars/10%25%20complete/", [], {"chars": r"10% complete"}), |
| 372 |
("special", NoReverseMatch, [""], {}), |
| 373 |
("mixed", "/john/0/", [], {"name": "john"}), |
| 374 |
("repeats", "/repeats/a/", [], {}), |
| 375 |
("repeats2", "/repeats/aa/", [], {}), |
| 376 |
("repeats3", "/repeats/aa/", [], {}), |
| 377 |
("test", "/test/1", [], {}), |
| 378 |
("inner-nothing", "/outer/42/", [], {"outer": "42"}), |
| 379 |
("inner-nothing", "/outer/42/", ["42"], {}), |
| 380 |
("inner-nothing", NoReverseMatch, ["foo"], {}), |
| 381 |
("inner-extra", "/outer/42/extra/inner/", [], {"extra": "inner", "outer": "42"}), |
| 382 |
("inner-extra", "/outer/42/extra/inner/", ["42", "inner"], {}), |
| 383 |
("inner-extra", NoReverseMatch, ["fred", "inner"], {}), |
| 384 |
("inner-no-kwargs", "/outer-no-kwargs/42/inner-no-kwargs/1/", ["42", "1"], {}), |
| 385 |
("disjunction", NoReverseMatch, ["foo"], {}), |
| 386 |
("inner-disjunction", NoReverseMatch, ["10", "11"], {}), |
| 387 |
("extra-places", "/e-places/10/", ["10"], {}), |
| 388 |
("extra-people", "/e-people/fred/", ["fred"], {}), |
| 389 |
("extra-people", "/e-people/fred/", [], {"name": "fred"}), |
| 390 |
("part", "/part/one/", [], {"value": "one"}), |
| 391 |
("part", "/prefix/xx/part/one/", [], {"value": "one", "prefix": "xx"}), |
| 392 |
("part2", "/part2/one/", [], {"value": "one"}), |
| 393 |
("part2", "/part2/", [], {}), |
| 394 |
("part2", "/prefix/xx/part2/one/", [], {"value": "one", "prefix": "xx"}), |
| 395 |
("part2", "/prefix/xx/part2/", [], {"prefix": "xx"}), |
| 396 |
# Tests for nested groups. Nested capturing groups will only work if you |
| 397 |
# *only* supply the correct outer group. |
| 398 |
("nested-noncapture", "/nested/noncapture/opt", [], {"p": "opt"}), |
| 399 |
("nested-capture", "/nested/capture/opt/", ["opt/"], {}), |
| 400 |
("nested-capture", NoReverseMatch, [], {"p": "opt"}), |
| 401 |
("nested-mixedcapture", "/nested/capture/mixed/opt", ["opt"], {}), |
| 402 |
("nested-mixedcapture", NoReverseMatch, [], {"p": "opt"}), |
| 403 |
("nested-namedcapture", "/nested/capture/named/opt/", [], {"outer": "opt/"}), |
| 404 |
("nested-namedcapture", NoReverseMatch, [], {"outer": "opt/", "inner": "opt"}), |
| 405 |
("nested-namedcapture", NoReverseMatch, [], {"inner": "opt"}), |
| 406 |
("non_path_include", "/includes/non_path_include/", [], {}), |
| 407 |
# Tests for #13154 |
| 408 |
("defaults", "/defaults_view1/3/", [], {"arg1": 3, "arg2": 1}), |
| 409 |
("defaults", "/defaults_view2/3/", [], {"arg1": 3, "arg2": 2}), |
| 410 |
("defaults", NoReverseMatch, [], {"arg1": 3, "arg2": 3}), |
| 411 |
("defaults", NoReverseMatch, [], {"arg2": 1}), |
| 412 |
# Security tests |
| 413 |
("security", "/%2Fexample.com/security/", ["/example.com"], {}), |
| 414 |
) |
| 415 |
|
| 416 |
|
| 417 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.no_urls") |
| 418 |
class NoURLPatternsTests(SimpleTestCase): |
| 419 |
def test_no_urls_exception(self): |
| 420 |
""" |
| 421 |
URLResolver should raise an exception when no urlpatterns exist. |
| 422 |
""" |
| 423 |
resolver = URLResolver(RegexPattern(r"^$"), settings.ROOT_URLCONF) |
| 424 |
|
| 425 |
with self.assertRaisesMessage( |
| 426 |
ImproperlyConfigured, |
| 427 |
"The included URLconf 'urlpatterns_reverse.no_urls' does not " |
| 428 |
"appear to have any patterns in it. If you see the 'urlpatterns' " |
| 429 |
"variable with valid patterns in the file then the issue is " |
| 430 |
"probably caused by a circular import.", |
| 431 |
): |
| 432 |
getattr(resolver, "url_patterns") |
| 433 |
|
| 434 |
|
| 435 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.urls") |
| 436 |
class URLPatternReverse(SimpleTestCase): |
| 437 |
def test_urlpattern_reverse(self): |
| 438 |
for name, expected, args, kwargs in test_data: |
| 439 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 440 |
try: |
| 441 |
got = reverse(name, args=args, kwargs=kwargs) |
| 442 |
except NoReverseMatch: |
| 443 |
self.assertEqual(NoReverseMatch, expected) |
| 444 |
else: |
| 445 |
self.assertEqual(got, expected) |
| 446 |
|
| 447 |
def test_reverse_none(self): |
| 448 |
# Reversing None should raise an error, not return the last un-named view. |
| 449 |
with self.assertRaises(NoReverseMatch): |
| 450 |
reverse(None) |
| 451 |
|
| 452 |
def test_mixing_args_and_kwargs(self): |
| 453 |
msg = "Don't mix *args and **kwargs in call to reverse()!" |
| 454 |
with self.assertRaisesMessage(ValueError, msg): |
| 455 |
reverse("name", args=["a"], kwargs={"b": "c"}) |
| 456 |
|
| 457 |
@override_script_prefix("/{{invalid}}/") |
| 458 |
def test_prefix_braces(self): |
| 459 |
self.assertEqual( |
| 460 |
"/%7B%7Binvalid%7D%7D/includes/non_path_include/", |
| 461 |
reverse("non_path_include"), |
| 462 |
) |
| 463 |
|
| 464 |
def test_prefix_parenthesis(self): |
| 465 |
# Parentheses are allowed and should not cause errors or be escaped |
| 466 |
with override_script_prefix("/bogus)/"): |
| 467 |
self.assertEqual( |
| 468 |
"/bogus)/includes/non_path_include/", reverse("non_path_include") |
| 469 |
) |
| 470 |
with override_script_prefix("/(bogus)/"): |
| 471 |
self.assertEqual( |
| 472 |
"/(bogus)/includes/non_path_include/", reverse("non_path_include") |
| 473 |
) |
| 474 |
|
| 475 |
@override_script_prefix("/bump%20map/") |
| 476 |
def test_prefix_format_char(self): |
| 477 |
self.assertEqual( |
| 478 |
"/bump%2520map/includes/non_path_include/", reverse("non_path_include") |
| 479 |
) |
| 480 |
|
| 481 |
@override_script_prefix("/%7Eme/") |
| 482 |
def test_non_urlsafe_prefix_with_args(self): |
| 483 |
# Regression for #20022, adjusted for #24013 because ~ is an unreserved |
| 484 |
# character. Tests whether % is escaped. |
| 485 |
self.assertEqual("/%257Eme/places/1/", reverse("places", args=[1])) |
| 486 |
|
| 487 |
def test_patterns_reported(self): |
| 488 |
# Regression for #17076 |
| 489 |
with self.assertRaisesMessage( |
| 490 |
NoReverseMatch, r"1 pattern(s) tried: ['people/(?P<name>\\w+)/$']" |
| 491 |
): |
| 492 |
# this url exists, but requires an argument |
| 493 |
reverse("people", args=[]) |
| 494 |
|
| 495 |
@override_script_prefix("/script:name/") |
| 496 |
def test_script_name_escaping(self): |
| 497 |
self.assertEqual( |
| 498 |
reverse("optional", args=["foo:bar"]), "/script:name/optional/foo:bar/" |
| 499 |
) |
| 500 |
|
| 501 |
def test_view_not_found_message(self): |
| 502 |
msg = ( |
| 503 |
"Reverse for 'nonexistent-view' not found. 'nonexistent-view' " |
| 504 |
"is not a valid view function or pattern name." |
| 505 |
) |
| 506 |
with self.assertRaisesMessage(NoReverseMatch, msg): |
| 507 |
reverse("nonexistent-view") |
| 508 |
|
| 509 |
def test_no_args_message(self): |
| 510 |
msg = "Reverse for 'places' with no arguments not found. 1 pattern(s) tried:" |
| 511 |
with self.assertRaisesMessage(NoReverseMatch, msg): |
| 512 |
reverse("places") |
| 513 |
|
| 514 |
def test_illegal_args_message(self): |
| 515 |
msg = ( |
| 516 |
"Reverse for 'places' with arguments '(1, 2)' not found. 1 pattern(s) " |
| 517 |
"tried:" |
| 518 |
) |
| 519 |
with self.assertRaisesMessage(NoReverseMatch, msg): |
| 520 |
reverse("places", args=(1, 2)) |
| 521 |
|
| 522 |
def test_illegal_kwargs_message(self): |
| 523 |
msg = ( |
| 524 |
"Reverse for 'places' with keyword arguments '{'arg1': 2}' not found. 1 " |
| 525 |
"pattern(s) tried:" |
| 526 |
) |
| 527 |
with self.assertRaisesMessage(NoReverseMatch, msg): |
| 528 |
reverse("places", kwargs={"arg1": 2}) |
| 529 |
|
| 530 |
def test_view_func_from_cbv(self): |
| 531 |
expected = "/hello/world/" |
| 532 |
url = reverse(views.view_func_from_cbv, kwargs={"name": "world"}) |
| 533 |
self.assertEqual(url, expected) |
| 534 |
|
| 535 |
def test_view_func_from_cbv_no_expected_kwarg(self): |
| 536 |
with self.assertRaises(NoReverseMatch): |
| 537 |
reverse(views.view_func_from_cbv) |
| 538 |
|
| 539 |
def test_reverse_with_query(self): |
| 540 |
self.assertEqual( |
| 541 |
reverse("test", query={"hello": "world", "foo": 123}), |
| 542 |
"/test/1?hello=world&foo=123", |
| 543 |
) |
| 544 |
|
| 545 |
def test_reverse_with_query_sequences(self): |
| 546 |
cases = [ |
| 547 |
[("hello", "world"), ("foo", 123), ("foo", 456)], |
| 548 |
(("hello", "world"), ("foo", 123), ("foo", 456)), |
| 549 |
{"hello": "world", "foo": (123, 456)}, |
| 550 |
] |
| 551 |
for query in cases: |
| 552 |
with self.subTest(query=query): |
| 553 |
self.assertEqual( |
| 554 |
reverse("test", query=query), "/test/1?hello=world&foo=123&foo=456" |
| 555 |
) |
| 556 |
|
| 557 |
def test_reverse_with_fragment(self): |
| 558 |
self.assertEqual(reverse("test", fragment="tab-1"), "/test/1#tab-1") |
| 559 |
|
| 560 |
def test_reverse_with_fragment_not_encoded(self): |
| 561 |
self.assertEqual( |
| 562 |
reverse("test", fragment="tab 1 is the best!"), "/test/1#tab 1 is the best!" |
| 563 |
) |
| 564 |
|
| 565 |
def test_reverse_with_query_and_fragment(self): |
| 566 |
self.assertEqual( |
| 567 |
reverse("test", query={"hello": "world", "foo": 123}, fragment="tab-1"), |
| 568 |
"/test/1?hello=world&foo=123#tab-1", |
| 569 |
) |
| 570 |
|
| 571 |
def test_reverse_with_empty_fragment(self): |
| 572 |
self.assertEqual(reverse("test", fragment=None), "/test/1") |
| 573 |
self.assertEqual(reverse("test", fragment=""), "/test/1#") |
| 574 |
|
| 575 |
def test_reverse_with_invalid_fragment(self): |
| 576 |
cases = [0, False, {}, [], set(), ()] |
| 577 |
for fragment in cases: |
| 578 |
with self.subTest(fragment=fragment): |
| 579 |
with self.assertRaises(TypeError): |
| 580 |
reverse("test", fragment=fragment) |
| 581 |
|
| 582 |
def test_reverse_with_empty_query(self): |
| 583 |
cases = [None, "", {}, [], set(), (), QueryDict()] |
| 584 |
for query in cases: |
| 585 |
with self.subTest(query=query): |
| 586 |
self.assertEqual(reverse("test", query=query), "/test/1") |
| 587 |
|
| 588 |
def test_reverse_with_invalid_query(self): |
| 589 |
cases = [0, False, [1, 3, 5], {1, 2, 3}] |
| 590 |
for query in cases: |
| 591 |
with self.subTest(query=query): |
| 592 |
with self.assertRaises(TypeError): |
| 593 |
print(reverse("test", query=query)) |
| 594 |
|
| 595 |
def test_reverse_encodes_query_string(self): |
| 596 |
self.assertEqual( |
| 597 |
reverse( |
| 598 |
"test", |
| 599 |
query={ |
| 600 |
"hello world": "django project", |
| 601 |
"foo": [123, 456], |
| 602 |
"@invalid": ["?", "!", "a b"], |
| 603 |
}, |
| 604 |
), |
| 605 |
"/test/1?hello+world=django+project&foo=123&foo=456" |
| 606 |
"&%40invalid=%3F&%40invalid=%21&%40invalid=a+b", |
| 607 |
) |
| 608 |
|
| 609 |
def test_reverse_with_query_from_querydict(self): |
| 610 |
query_string = "a=1&b=2&b=3&c=4" |
| 611 |
query_dict = QueryDict(query_string) |
| 612 |
self.assertEqual(reverse("test", query=query_dict), f"/test/1?{query_string}") |
| 613 |
|
| 614 |
|
| 615 |
class ResolverTests(SimpleTestCase): |
| 616 |
def test_resolver_repr(self): |
| 617 |
""" |
| 618 |
Test repr of URLResolver, especially when urlconf_name is a list |
| 619 |
(#17892). |
| 620 |
""" |
| 621 |
# Pick a resolver from a namespaced URLconf |
| 622 |
resolver = get_resolver("urlpatterns_reverse.namespace_urls") |
| 623 |
sub_resolver = resolver.namespace_dict["test-ns1"][1] |
| 624 |
self.assertIn("<URLPattern list>", repr(sub_resolver)) |
| 625 |
|
| 626 |
def test_reverse_lazy_object_coercion_by_resolve(self): |
| 627 |
""" |
| 628 |
Verifies lazy object returned by reverse_lazy is coerced to |
| 629 |
text by resolve(). Previous to #21043, this would raise a TypeError. |
| 630 |
""" |
| 631 |
urls = "urlpatterns_reverse.named_urls" |
| 632 |
proxy_url = reverse_lazy("named-url1", urlconf=urls) |
| 633 |
resolver = get_resolver(urls) |
| 634 |
resolver.resolve(proxy_url) |
| 635 |
|
| 636 |
def test_resolver_reverse(self): |
| 637 |
resolver = get_resolver("urlpatterns_reverse.named_urls") |
| 638 |
test_urls = [ |
| 639 |
# (name, args, kwargs, expected) |
| 640 |
("named-url1", (), {}, ""), |
| 641 |
("named-url2", ("arg",), {}, "extra/arg/"), |
| 642 |
("named-url2", (), {"extra": "arg"}, "extra/arg/"), |
| 643 |
] |
| 644 |
for name, args, kwargs, expected in test_urls: |
| 645 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 646 |
self.assertEqual(resolver.reverse(name, *args, **kwargs), expected) |
| 647 |
|
| 648 |
def test_resolver_reverse_conflict(self): |
| 649 |
""" |
| 650 |
URL pattern name arguments don't need to be unique. The last registered |
| 651 |
pattern takes precedence for conflicting names. |
| 652 |
""" |
| 653 |
resolver = get_resolver("urlpatterns_reverse.named_urls_conflict") |
| 654 |
test_urls = [ |
| 655 |
# (name, args, kwargs, expected) |
| 656 |
# Without arguments, the last URL in urlpatterns has precedence. |
| 657 |
("name-conflict", (), {}, "conflict/"), |
| 658 |
# With an arg, the last URL in urlpatterns has precedence. |
| 659 |
("name-conflict", ("arg",), {}, "conflict-last/arg/"), |
| 660 |
# With a kwarg, other URL patterns can be reversed. |
| 661 |
("name-conflict", (), {"first": "arg"}, "conflict-first/arg/"), |
| 662 |
("name-conflict", (), {"middle": "arg"}, "conflict-middle/arg/"), |
| 663 |
("name-conflict", (), {"last": "arg"}, "conflict-last/arg/"), |
| 664 |
# The number and order of the arguments don't interfere with reversing. |
| 665 |
("name-conflict", ("arg", "arg"), {}, "conflict/arg/arg/"), |
| 666 |
] |
| 667 |
for name, args, kwargs, expected in test_urls: |
| 668 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 669 |
self.assertEqual(resolver.reverse(name, *args, **kwargs), expected) |
| 670 |
|
| 671 |
def test_non_regex(self): |
| 672 |
""" |
| 673 |
A Resolver404 is raised if resolving doesn't meet the basic |
| 674 |
requirements of a path to match - i.e., at the very least, it matches |
| 675 |
the root pattern '^/'. Never return None from resolve() to prevent a |
| 676 |
TypeError from occurring later (#10834). |
| 677 |
""" |
| 678 |
test_urls = ["", "a", "\\", "."] |
| 679 |
for path_ in test_urls: |
| 680 |
with self.subTest(path=path_): |
| 681 |
with self.assertRaises(Resolver404): |
| 682 |
resolve(path_) |
| 683 |
|
| 684 |
def test_404_tried_urls_have_names(self): |
| 685 |
""" |
| 686 |
The list of URLs that come back from a Resolver404 exception contains |
| 687 |
a list in the right format for printing out in the DEBUG 404 page with |
| 688 |
both the patterns and URL names, if available. |
| 689 |
""" |
| 690 |
urls = "urlpatterns_reverse.named_urls" |
| 691 |
# this list matches the expected URL types and names returned when |
| 692 |
# you try to resolve a nonexistent URL in the first level of included |
| 693 |
# URLs in named_urls.py (e.g., '/included/nonexistent-url') |
| 694 |
url_types_names = [ |
| 695 |
[{"type": URLPattern, "name": "named-url1"}], |
| 696 |
[{"type": URLPattern, "name": "named-url2"}], |
| 697 |
[{"type": URLPattern, "name": None}], |
| 698 |
[{"type": URLResolver}, {"type": URLPattern, "name": "named-url3"}], |
| 699 |
[{"type": URLResolver}, {"type": URLPattern, "name": "named-url4"}], |
| 700 |
[{"type": URLResolver}, {"type": URLPattern, "name": None}], |
| 701 |
[{"type": URLResolver}, {"type": URLResolver}], |
| 702 |
] |
| 703 |
with self.assertRaisesMessage(Resolver404, "tried") as cm: |
| 704 |
resolve("/included/nonexistent-url", urlconf=urls) |
| 705 |
e = cm.exception |
| 706 |
# make sure we at least matched the root ('/') url resolver: |
| 707 |
self.assertIn("tried", e.args[0]) |
| 708 |
self.assertEqual( |
| 709 |
len(e.args[0]["tried"]), |
| 710 |
len(url_types_names), |
| 711 |
"Wrong number of tried URLs returned. Expected %s, got %s." |
| 712 |
% (len(url_types_names), len(e.args[0]["tried"])), |
| 713 |
) |
| 714 |
for tried, expected in zip(e.args[0]["tried"], url_types_names): |
| 715 |
for t, e in zip(tried, expected): |
| 716 |
with self.subTest(t): |
| 717 |
self.assertIsInstance( |
| 718 |
t, e["type"] |
| 719 |
), "%s is not an instance of %s" % (t, e["type"]) |
| 720 |
if "name" in e: |
| 721 |
if not e["name"]: |
| 722 |
self.assertIsNone( |
| 723 |
t.name, "Expected no URL name but found %s." % t.name |
| 724 |
) |
| 725 |
else: |
| 726 |
self.assertEqual( |
| 727 |
t.name, |
| 728 |
e["name"], |
| 729 |
'Wrong URL name. Expected "%s", got "%s".' |
| 730 |
% (e["name"], t.name), |
| 731 |
) |
| 732 |
|
| 733 |
def test_namespaced_view_detail(self): |
| 734 |
resolver = get_resolver("urlpatterns_reverse.nested_urls") |
| 735 |
self.assertTrue(resolver._is_callback("urlpatterns_reverse.nested_urls.view1")) |
| 736 |
self.assertTrue(resolver._is_callback("urlpatterns_reverse.nested_urls.view2")) |
| 737 |
self.assertTrue(resolver._is_callback("urlpatterns_reverse.nested_urls.View3")) |
| 738 |
self.assertFalse(resolver._is_callback("urlpatterns_reverse.nested_urls.blub")) |
| 739 |
|
| 740 |
def test_view_detail_as_method(self): |
| 741 |
# Views which have a class name as part of their path. |
| 742 |
resolver = get_resolver("urlpatterns_reverse.method_view_urls") |
| 743 |
self.assertTrue( |
| 744 |
resolver._is_callback( |
| 745 |
"urlpatterns_reverse.method_view_urls.ViewContainer.method_view" |
| 746 |
) |
| 747 |
) |
| 748 |
self.assertTrue( |
| 749 |
resolver._is_callback( |
| 750 |
"urlpatterns_reverse.method_view_urls.ViewContainer.classmethod_view" |
| 751 |
) |
| 752 |
) |
| 753 |
|
| 754 |
def test_populate_concurrency(self): |
| 755 |
""" |
| 756 |
URLResolver._populate() can be called concurrently, but not more |
| 757 |
than once per thread (#26888). |
| 758 |
""" |
| 759 |
resolver = URLResolver(RegexPattern(r"^/"), "urlpatterns_reverse.urls") |
| 760 |
resolver._local.populating = True |
| 761 |
thread = threading.Thread(target=resolver._populate) |
| 762 |
thread.start() |
| 763 |
thread.join() |
| 764 |
self.assertNotEqual(resolver._reverse_dict, {}) |
| 765 |
|
| 766 |
|
| 767 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.reverse_lazy_urls") |
| 768 |
class ReverseLazyTest(TestCase): |
| 769 |
def test_redirect_with_lazy_reverse(self): |
| 770 |
response = self.client.get("/redirect/") |
| 771 |
self.assertRedirects(response, "/redirected_to/", status_code=302) |
| 772 |
|
| 773 |
def test_user_permission_with_lazy_reverse(self): |
| 774 |
alfred = User.objects.create_user( |
| 775 |
"alfred", "[email protected]", password="testpw" |
| 776 |
) |
| 777 |
response = self.client.get("/login_required_view/") |
| 778 |
self.assertRedirects( |
| 779 |
response, "/login/?next=/login_required_view/", status_code=302 |
| 780 |
) |
| 781 |
self.client.force_login(alfred) |
| 782 |
response = self.client.get("/login_required_view/") |
| 783 |
self.assertEqual(response.status_code, 200) |
| 784 |
|
| 785 |
def test_inserting_reverse_lazy_into_string(self): |
| 786 |
self.assertEqual( |
| 787 |
"Some URL: %s" % reverse_lazy("some-login-page"), "Some URL: /login/" |
| 788 |
) |
| 789 |
|
| 790 |
def test_build_absolute_uri(self): |
| 791 |
factory = RequestFactory() |
| 792 |
request = factory.get("/") |
| 793 |
self.assertEqual( |
| 794 |
request.build_absolute_uri(reverse_lazy("some-login-page")), |
| 795 |
"http://testserver/login/", |
| 796 |
) |
| 797 |
|
| 798 |
|
| 799 |
class ReverseLazySettingsTest(AdminScriptTestCase): |
| 800 |
""" |
| 801 |
reverse_lazy can be used in settings without causing a circular |
| 802 |
import error. |
| 803 |
""" |
| 804 |
|
| 805 |
def setUp(self): |
| 806 |
super().setUp() |
| 807 |
self.write_settings( |
| 808 |
"settings.py", |
| 809 |
extra=( |
| 810 |
"from django.urls import reverse_lazy\n" |
| 811 |
"LOGIN_URL = reverse_lazy('login')" |
| 812 |
), |
| 813 |
) |
| 814 |
|
| 815 |
def test_lazy_in_settings(self): |
| 816 |
out, err = self.run_manage(["check"]) |
| 817 |
self.assertNoOutput(err) |
| 818 |
|
| 819 |
|
| 820 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.urls") |
| 821 |
class ReverseShortcutTests(SimpleTestCase): |
| 822 |
def test_redirect_to_object(self): |
| 823 |
# We don't really need a model; just something with a get_absolute_url |
| 824 |
class FakeObj: |
| 825 |
def get_absolute_url(self): |
| 826 |
return "/hi-there/" |
| 827 |
|
| 828 |
res = redirect(FakeObj()) |
| 829 |
self.assertIsInstance(res, HttpResponseRedirect) |
| 830 |
self.assertEqual(res.url, "/hi-there/") |
| 831 |
|
| 832 |
res = redirect(FakeObj(), permanent=True) |
| 833 |
self.assertIsInstance(res, HttpResponsePermanentRedirect) |
| 834 |
self.assertEqual(res.url, "/hi-there/") |
| 835 |
|
| 836 |
def test_redirect_to_view_name(self): |
| 837 |
res = redirect("hardcoded2") |
| 838 |
self.assertEqual(res.url, "/hardcoded/doc.pdf") |
| 839 |
res = redirect("places", 1) |
| 840 |
self.assertEqual(res.url, "/places/1/") |
| 841 |
res = redirect("headlines", year="2008", month="02", day="17") |
| 842 |
self.assertEqual(res.url, "/headlines/2008.02.17/") |
| 843 |
with self.assertRaises(NoReverseMatch): |
| 844 |
redirect("not-a-view") |
| 845 |
|
| 846 |
def test_redirect_to_url(self): |
| 847 |
res = redirect("/foo/") |
| 848 |
self.assertEqual(res.url, "/foo/") |
| 849 |
res = redirect("http://example.com/") |
| 850 |
self.assertEqual(res.url, "http://example.com/") |
| 851 |
# Assert that we can redirect using UTF-8 strings |
| 852 |
res = redirect("/æøå/abc/") |
| 853 |
self.assertEqual(res.url, "/%C3%A6%C3%B8%C3%A5/abc/") |
| 854 |
# Assert that no imports are attempted when dealing with a relative path |
| 855 |
# (previously, the below would resolve in a UnicodeEncodeError from __import__ ) |
| 856 |
res = redirect("/æøå.abc/") |
| 857 |
self.assertEqual(res.url, "/%C3%A6%C3%B8%C3%A5.abc/") |
| 858 |
res = redirect("os.path") |
| 859 |
self.assertEqual(res.url, "os.path") |
| 860 |
|
| 861 |
def test_no_illegal_imports(self): |
| 862 |
# modules that are not listed in urlpatterns should not be importable |
| 863 |
redirect("urlpatterns_reverse.nonimported_module.view") |
| 864 |
self.assertNotIn("urlpatterns_reverse.nonimported_module", sys.modules) |
| 865 |
|
| 866 |
def test_reverse_by_path_nested(self): |
| 867 |
# Views added to urlpatterns using include() should be reversible. |
| 868 |
from .views import nested_view |
| 869 |
|
| 870 |
self.assertEqual(reverse(nested_view), "/includes/nested_path/") |
| 871 |
|
| 872 |
def test_redirect_view_object(self): |
| 873 |
from .views import absolute_kwargs_view |
| 874 |
|
| 875 |
res = redirect(absolute_kwargs_view) |
| 876 |
self.assertEqual(res.url, "/absolute_arg_view/") |
| 877 |
with self.assertRaises(NoReverseMatch): |
| 878 |
redirect(absolute_kwargs_view, wrong_argument=None) |
| 879 |
|
| 880 |
|
| 881 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.namespace_urls") |
| 882 |
class NamespaceTests(SimpleTestCase): |
| 883 |
def test_ambiguous_object(self): |
| 884 |
""" |
| 885 |
Names deployed via dynamic URL objects that require namespaces can't |
| 886 |
be resolved. |
| 887 |
""" |
| 888 |
test_urls = [ |
| 889 |
("urlobject-view", [], {}), |
| 890 |
("urlobject-view", [37, 42], {}), |
| 891 |
("urlobject-view", [], {"arg1": 42, "arg2": 37}), |
| 892 |
] |
| 893 |
for name, args, kwargs in test_urls: |
| 894 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 895 |
with self.assertRaises(NoReverseMatch): |
| 896 |
reverse(name, args=args, kwargs=kwargs) |
| 897 |
|
| 898 |
def test_ambiguous_urlpattern(self): |
| 899 |
""" |
| 900 |
Names deployed via dynamic URL objects that require namespaces can't |
| 901 |
be resolved. |
| 902 |
""" |
| 903 |
test_urls = [ |
| 904 |
("inner-nothing", [], {}), |
| 905 |
("inner-nothing", [37, 42], {}), |
| 906 |
("inner-nothing", [], {"arg1": 42, "arg2": 37}), |
| 907 |
] |
| 908 |
for name, args, kwargs in test_urls: |
| 909 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 910 |
with self.assertRaises(NoReverseMatch): |
| 911 |
reverse(name, args=args, kwargs=kwargs) |
| 912 |
|
| 913 |
def test_non_existent_namespace(self): |
| 914 |
"""Nonexistent namespaces raise errors.""" |
| 915 |
test_urls = [ |
| 916 |
"blahblah:urlobject-view", |
| 917 |
"test-ns1:blahblah:urlobject-view", |
| 918 |
] |
| 919 |
for name in test_urls: |
| 920 |
with self.subTest(name=name): |
| 921 |
with self.assertRaises(NoReverseMatch): |
| 922 |
reverse(name) |
| 923 |
|
| 924 |
def test_normal_name(self): |
| 925 |
"""Normal lookups work as expected.""" |
| 926 |
test_urls = [ |
| 927 |
("normal-view", [], {}, "/normal/"), |
| 928 |
("normal-view", [37, 42], {}, "/normal/37/42/"), |
| 929 |
("normal-view", [], {"arg1": 42, "arg2": 37}, "/normal/42/37/"), |
| 930 |
("special-view", [], {}, "/+%5C$*/"), |
| 931 |
] |
| 932 |
for name, args, kwargs, expected in test_urls: |
| 933 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 934 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 935 |
|
| 936 |
def test_simple_included_name(self): |
| 937 |
"""Normal lookups work on names included from other patterns.""" |
| 938 |
test_urls = [ |
| 939 |
("included_namespace_urls:inc-normal-view", [], {}, "/included/normal/"), |
| 940 |
( |
| 941 |
"included_namespace_urls:inc-normal-view", |
| 942 |
[37, 42], |
| 943 |
{}, |
| 944 |
"/included/normal/37/42/", |
| 945 |
), |
| 946 |
( |
| 947 |
"included_namespace_urls:inc-normal-view", |
| 948 |
[], |
| 949 |
{"arg1": 42, "arg2": 37}, |
| 950 |
"/included/normal/42/37/", |
| 951 |
), |
| 952 |
("included_namespace_urls:inc-special-view", [], {}, "/included/+%5C$*/"), |
| 953 |
] |
| 954 |
for name, args, kwargs, expected in test_urls: |
| 955 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 956 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 957 |
|
| 958 |
def test_namespace_object(self): |
| 959 |
"""Dynamic URL objects can be found using a namespace.""" |
| 960 |
test_urls = [ |
| 961 |
("test-ns1:urlobject-view", [], {}, "/test1/inner/"), |
| 962 |
("test-ns1:urlobject-view", [37, 42], {}, "/test1/inner/37/42/"), |
| 963 |
( |
| 964 |
"test-ns1:urlobject-view", |
| 965 |
[], |
| 966 |
{"arg1": 42, "arg2": 37}, |
| 967 |
"/test1/inner/42/37/", |
| 968 |
), |
| 969 |
("test-ns1:urlobject-special-view", [], {}, "/test1/inner/+%5C$*/"), |
| 970 |
] |
| 971 |
for name, args, kwargs, expected in test_urls: |
| 972 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 973 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 974 |
|
| 975 |
def test_app_object(self): |
| 976 |
""" |
| 977 |
Dynamic URL objects can return a (pattern, app_name) 2-tuple, and |
| 978 |
include() can set the namespace. |
| 979 |
""" |
| 980 |
test_urls = [ |
| 981 |
("new-ns1:urlobject-view", [], {}, "/newapp1/inner/"), |
| 982 |
("new-ns1:urlobject-view", [37, 42], {}, "/newapp1/inner/37/42/"), |
| 983 |
( |
| 984 |
"new-ns1:urlobject-view", |
| 985 |
[], |
| 986 |
{"arg1": 42, "arg2": 37}, |
| 987 |
"/newapp1/inner/42/37/", |
| 988 |
), |
| 989 |
("new-ns1:urlobject-special-view", [], {}, "/newapp1/inner/+%5C$*/"), |
| 990 |
] |
| 991 |
for name, args, kwargs, expected in test_urls: |
| 992 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 993 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 994 |
|
| 995 |
def test_app_object_default_namespace(self): |
| 996 |
""" |
| 997 |
Namespace defaults to app_name when including a (pattern, app_name) |
| 998 |
2-tuple. |
| 999 |
""" |
| 1000 |
test_urls = [ |
| 1001 |
("newapp:urlobject-view", [], {}, "/new-default/inner/"), |
| 1002 |
("newapp:urlobject-view", [37, 42], {}, "/new-default/inner/37/42/"), |
| 1003 |
( |
| 1004 |
"newapp:urlobject-view", |
| 1005 |
[], |
| 1006 |
{"arg1": 42, "arg2": 37}, |
| 1007 |
"/new-default/inner/42/37/", |
| 1008 |
), |
| 1009 |
("newapp:urlobject-special-view", [], {}, "/new-default/inner/+%5C$*/"), |
| 1010 |
] |
| 1011 |
for name, args, kwargs, expected in test_urls: |
| 1012 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1013 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1014 |
|
| 1015 |
def test_embedded_namespace_object(self): |
| 1016 |
"""Namespaces can be installed anywhere in the URL pattern tree.""" |
| 1017 |
test_urls = [ |
| 1018 |
( |
| 1019 |
"included_namespace_urls:test-ns3:urlobject-view", |
| 1020 |
[], |
| 1021 |
{}, |
| 1022 |
"/included/test3/inner/", |
| 1023 |
), |
| 1024 |
( |
| 1025 |
"included_namespace_urls:test-ns3:urlobject-view", |
| 1026 |
[37, 42], |
| 1027 |
{}, |
| 1028 |
"/included/test3/inner/37/42/", |
| 1029 |
), |
| 1030 |
( |
| 1031 |
"included_namespace_urls:test-ns3:urlobject-view", |
| 1032 |
[], |
| 1033 |
{"arg1": 42, "arg2": 37}, |
| 1034 |
"/included/test3/inner/42/37/", |
| 1035 |
), |
| 1036 |
( |
| 1037 |
"included_namespace_urls:test-ns3:urlobject-special-view", |
| 1038 |
[], |
| 1039 |
{}, |
| 1040 |
"/included/test3/inner/+%5C$*/", |
| 1041 |
), |
| 1042 |
] |
| 1043 |
for name, args, kwargs, expected in test_urls: |
| 1044 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1045 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1046 |
|
| 1047 |
def test_namespace_pattern(self): |
| 1048 |
"""Namespaces can be applied to include()'d urlpatterns.""" |
| 1049 |
test_urls = [ |
| 1050 |
("inc-ns1:inc-normal-view", [], {}, "/ns-included1/normal/"), |
| 1051 |
("inc-ns1:inc-normal-view", [37, 42], {}, "/ns-included1/normal/37/42/"), |
| 1052 |
( |
| 1053 |
"inc-ns1:inc-normal-view", |
| 1054 |
[], |
| 1055 |
{"arg1": 42, "arg2": 37}, |
| 1056 |
"/ns-included1/normal/42/37/", |
| 1057 |
), |
| 1058 |
("inc-ns1:inc-special-view", [], {}, "/ns-included1/+%5C$*/"), |
| 1059 |
] |
| 1060 |
for name, args, kwargs, expected in test_urls: |
| 1061 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1062 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1063 |
|
| 1064 |
def test_app_name_pattern(self): |
| 1065 |
""" |
| 1066 |
Namespaces can be applied to include()'d urlpatterns that set an |
| 1067 |
app_name attribute. |
| 1068 |
""" |
| 1069 |
test_urls = [ |
| 1070 |
("app-ns1:inc-normal-view", [], {}, "/app-included1/normal/"), |
| 1071 |
("app-ns1:inc-normal-view", [37, 42], {}, "/app-included1/normal/37/42/"), |
| 1072 |
( |
| 1073 |
"app-ns1:inc-normal-view", |
| 1074 |
[], |
| 1075 |
{"arg1": 42, "arg2": 37}, |
| 1076 |
"/app-included1/normal/42/37/", |
| 1077 |
), |
| 1078 |
("app-ns1:inc-special-view", [], {}, "/app-included1/+%5C$*/"), |
| 1079 |
] |
| 1080 |
for name, args, kwargs, expected in test_urls: |
| 1081 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1082 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1083 |
|
| 1084 |
def test_namespace_pattern_with_variable_prefix(self): |
| 1085 |
""" |
| 1086 |
Using include() with namespaces when there is a regex variable in front |
| 1087 |
of it. |
| 1088 |
""" |
| 1089 |
test_urls = [ |
| 1090 |
("inc-outer:inc-normal-view", [], {"outer": 42}, "/ns-outer/42/normal/"), |
| 1091 |
("inc-outer:inc-normal-view", [42], {}, "/ns-outer/42/normal/"), |
| 1092 |
( |
| 1093 |
"inc-outer:inc-normal-view", |
| 1094 |
[], |
| 1095 |
{"arg1": 37, "arg2": 4, "outer": 42}, |
| 1096 |
"/ns-outer/42/normal/37/4/", |
| 1097 |
), |
| 1098 |
("inc-outer:inc-normal-view", [42, 37, 4], {}, "/ns-outer/42/normal/37/4/"), |
| 1099 |
("inc-outer:inc-special-view", [], {"outer": 42}, "/ns-outer/42/+%5C$*/"), |
| 1100 |
("inc-outer:inc-special-view", [42], {}, "/ns-outer/42/+%5C$*/"), |
| 1101 |
] |
| 1102 |
for name, args, kwargs, expected in test_urls: |
| 1103 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1104 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1105 |
|
| 1106 |
def test_multiple_namespace_pattern(self): |
| 1107 |
"""Namespaces can be embedded.""" |
| 1108 |
test_urls = [ |
| 1109 |
("inc-ns1:test-ns3:urlobject-view", [], {}, "/ns-included1/test3/inner/"), |
| 1110 |
( |
| 1111 |
"inc-ns1:test-ns3:urlobject-view", |
| 1112 |
[37, 42], |
| 1113 |
{}, |
| 1114 |
"/ns-included1/test3/inner/37/42/", |
| 1115 |
), |
| 1116 |
( |
| 1117 |
"inc-ns1:test-ns3:urlobject-view", |
| 1118 |
[], |
| 1119 |
{"arg1": 42, "arg2": 37}, |
| 1120 |
"/ns-included1/test3/inner/42/37/", |
| 1121 |
), |
| 1122 |
( |
| 1123 |
"inc-ns1:test-ns3:urlobject-special-view", |
| 1124 |
[], |
| 1125 |
{}, |
| 1126 |
"/ns-included1/test3/inner/+%5C$*/", |
| 1127 |
), |
| 1128 |
] |
| 1129 |
for name, args, kwargs, expected in test_urls: |
| 1130 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1131 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1132 |
|
| 1133 |
def test_nested_namespace_pattern(self): |
| 1134 |
"""Namespaces can be nested.""" |
| 1135 |
test_urls = [ |
| 1136 |
( |
| 1137 |
"inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view", |
| 1138 |
[], |
| 1139 |
{}, |
| 1140 |
"/ns-included1/ns-included4/ns-included1/test3/inner/", |
| 1141 |
), |
| 1142 |
( |
| 1143 |
"inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view", |
| 1144 |
[37, 42], |
| 1145 |
{}, |
| 1146 |
"/ns-included1/ns-included4/ns-included1/test3/inner/37/42/", |
| 1147 |
), |
| 1148 |
( |
| 1149 |
"inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view", |
| 1150 |
[], |
| 1151 |
{"arg1": 42, "arg2": 37}, |
| 1152 |
"/ns-included1/ns-included4/ns-included1/test3/inner/42/37/", |
| 1153 |
), |
| 1154 |
( |
| 1155 |
"inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-special-view", |
| 1156 |
[], |
| 1157 |
{}, |
| 1158 |
"/ns-included1/ns-included4/ns-included1/test3/inner/+%5C$*/", |
| 1159 |
), |
| 1160 |
] |
| 1161 |
for name, args, kwargs, expected in test_urls: |
| 1162 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1163 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1164 |
|
| 1165 |
def test_app_lookup_object(self): |
| 1166 |
"""A default application namespace can be used for lookup.""" |
| 1167 |
test_urls = [ |
| 1168 |
("testapp:urlobject-view", [], {}, "/default/inner/"), |
| 1169 |
("testapp:urlobject-view", [37, 42], {}, "/default/inner/37/42/"), |
| 1170 |
( |
| 1171 |
"testapp:urlobject-view", |
| 1172 |
[], |
| 1173 |
{"arg1": 42, "arg2": 37}, |
| 1174 |
"/default/inner/42/37/", |
| 1175 |
), |
| 1176 |
("testapp:urlobject-special-view", [], {}, "/default/inner/+%5C$*/"), |
| 1177 |
] |
| 1178 |
for name, args, kwargs, expected in test_urls: |
| 1179 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1180 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1181 |
|
| 1182 |
def test_app_lookup_object_with_default(self): |
| 1183 |
"""A default application namespace is sensitive to the current app.""" |
| 1184 |
test_urls = [ |
| 1185 |
("testapp:urlobject-view", [], {}, "test-ns3", "/default/inner/"), |
| 1186 |
( |
| 1187 |
"testapp:urlobject-view", |
| 1188 |
[37, 42], |
| 1189 |
{}, |
| 1190 |
"test-ns3", |
| 1191 |
"/default/inner/37/42/", |
| 1192 |
), |
| 1193 |
( |
| 1194 |
"testapp:urlobject-view", |
| 1195 |
[], |
| 1196 |
{"arg1": 42, "arg2": 37}, |
| 1197 |
"test-ns3", |
| 1198 |
"/default/inner/42/37/", |
| 1199 |
), |
| 1200 |
( |
| 1201 |
"testapp:urlobject-special-view", |
| 1202 |
[], |
| 1203 |
{}, |
| 1204 |
"test-ns3", |
| 1205 |
"/default/inner/+%5C$*/", |
| 1206 |
), |
| 1207 |
] |
| 1208 |
for name, args, kwargs, current_app, expected in test_urls: |
| 1209 |
with self.subTest( |
| 1210 |
name=name, args=args, kwargs=kwargs, current_app=current_app |
| 1211 |
): |
| 1212 |
self.assertEqual( |
| 1213 |
reverse(name, args=args, kwargs=kwargs, current_app=current_app), |
| 1214 |
expected, |
| 1215 |
) |
| 1216 |
|
| 1217 |
def test_app_lookup_object_without_default(self): |
| 1218 |
""" |
| 1219 |
An application namespace without a default is sensitive to the current |
| 1220 |
app. |
| 1221 |
""" |
| 1222 |
test_urls = [ |
| 1223 |
("nodefault:urlobject-view", [], {}, None, "/other2/inner/"), |
| 1224 |
("nodefault:urlobject-view", [37, 42], {}, None, "/other2/inner/37/42/"), |
| 1225 |
( |
| 1226 |
"nodefault:urlobject-view", |
| 1227 |
[], |
| 1228 |
{"arg1": 42, "arg2": 37}, |
| 1229 |
None, |
| 1230 |
"/other2/inner/42/37/", |
| 1231 |
), |
| 1232 |
("nodefault:urlobject-special-view", [], {}, None, "/other2/inner/+%5C$*/"), |
| 1233 |
("nodefault:urlobject-view", [], {}, "other-ns1", "/other1/inner/"), |
| 1234 |
( |
| 1235 |
"nodefault:urlobject-view", |
| 1236 |
[37, 42], |
| 1237 |
{}, |
| 1238 |
"other-ns1", |
| 1239 |
"/other1/inner/37/42/", |
| 1240 |
), |
| 1241 |
( |
| 1242 |
"nodefault:urlobject-view", |
| 1243 |
[], |
| 1244 |
{"arg1": 42, "arg2": 37}, |
| 1245 |
"other-ns1", |
| 1246 |
"/other1/inner/42/37/", |
| 1247 |
), |
| 1248 |
( |
| 1249 |
"nodefault:urlobject-special-view", |
| 1250 |
[], |
| 1251 |
{}, |
| 1252 |
"other-ns1", |
| 1253 |
"/other1/inner/+%5C$*/", |
| 1254 |
), |
| 1255 |
] |
| 1256 |
for name, args, kwargs, current_app, expected in test_urls: |
| 1257 |
with self.subTest( |
| 1258 |
name=name, args=args, kwargs=kwargs, current_app=current_app |
| 1259 |
): |
| 1260 |
self.assertEqual( |
| 1261 |
reverse(name, args=args, kwargs=kwargs, current_app=current_app), |
| 1262 |
expected, |
| 1263 |
) |
| 1264 |
|
| 1265 |
def test_special_chars_namespace(self): |
| 1266 |
test_urls = [ |
| 1267 |
( |
| 1268 |
"special:included_namespace_urls:inc-normal-view", |
| 1269 |
[], |
| 1270 |
{}, |
| 1271 |
"/+%5C$*/included/normal/", |
| 1272 |
), |
| 1273 |
( |
| 1274 |
"special:included_namespace_urls:inc-normal-view", |
| 1275 |
[37, 42], |
| 1276 |
{}, |
| 1277 |
"/+%5C$*/included/normal/37/42/", |
| 1278 |
), |
| 1279 |
( |
| 1280 |
"special:included_namespace_urls:inc-normal-view", |
| 1281 |
[], |
| 1282 |
{"arg1": 42, "arg2": 37}, |
| 1283 |
"/+%5C$*/included/normal/42/37/", |
| 1284 |
), |
| 1285 |
( |
| 1286 |
"special:included_namespace_urls:inc-special-view", |
| 1287 |
[], |
| 1288 |
{}, |
| 1289 |
"/+%5C$*/included/+%5C$*/", |
| 1290 |
), |
| 1291 |
] |
| 1292 |
for name, args, kwargs, expected in test_urls: |
| 1293 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1294 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1295 |
|
| 1296 |
def test_namespaces_with_variables(self): |
| 1297 |
"""Namespace prefixes can capture variables.""" |
| 1298 |
test_urls = [ |
| 1299 |
("inc-ns5:inner-nothing", [], {"outer": "70"}, "/inc70/"), |
| 1300 |
( |
| 1301 |
"inc-ns5:inner-extra", |
| 1302 |
[], |
| 1303 |
{"extra": "foobar", "outer": "78"}, |
| 1304 |
"/inc78/extra/foobar/", |
| 1305 |
), |
| 1306 |
("inc-ns5:inner-nothing", ["70"], {}, "/inc70/"), |
| 1307 |
("inc-ns5:inner-extra", ["78", "foobar"], {}, "/inc78/extra/foobar/"), |
| 1308 |
] |
| 1309 |
for name, args, kwargs, expected in test_urls: |
| 1310 |
with self.subTest(name=name, args=args, kwargs=kwargs): |
| 1311 |
self.assertEqual(reverse(name, args=args, kwargs=kwargs), expected) |
| 1312 |
|
| 1313 |
def test_nested_app_lookup(self): |
| 1314 |
""" |
| 1315 |
A nested current_app should be split in individual namespaces (#24904). |
| 1316 |
""" |
| 1317 |
test_urls = [ |
| 1318 |
( |
| 1319 |
"inc-ns1:testapp:urlobject-view", |
| 1320 |
[], |
| 1321 |
{}, |
| 1322 |
None, |
| 1323 |
"/ns-included1/test4/inner/", |
| 1324 |
), |
| 1325 |
( |
| 1326 |
"inc-ns1:testapp:urlobject-view", |
| 1327 |
[37, 42], |
| 1328 |
{}, |
| 1329 |
None, |
| 1330 |
"/ns-included1/test4/inner/37/42/", |
| 1331 |
), |
| 1332 |
( |
| 1333 |
"inc-ns1:testapp:urlobject-view", |
| 1334 |
[], |
| 1335 |
{"arg1": 42, "arg2": 37}, |
| 1336 |
None, |
| 1337 |
"/ns-included1/test4/inner/42/37/", |
| 1338 |
), |
| 1339 |
( |
| 1340 |
"inc-ns1:testapp:urlobject-special-view", |
| 1341 |
[], |
| 1342 |
{}, |
| 1343 |
None, |
| 1344 |
"/ns-included1/test4/inner/+%5C$*/", |
| 1345 |
), |
| 1346 |
( |
| 1347 |
"inc-ns1:testapp:urlobject-view", |
| 1348 |
[], |
| 1349 |
{}, |
| 1350 |
"inc-ns1:test-ns3", |
| 1351 |
"/ns-included1/test3/inner/", |
| 1352 |
), |
| 1353 |
( |
| 1354 |
"inc-ns1:testapp:urlobject-view", |
| 1355 |
[37, 42], |
| 1356 |
{}, |
| 1357 |
"inc-ns1:test-ns3", |
| 1358 |
"/ns-included1/test3/inner/37/42/", |
| 1359 |
), |
| 1360 |
( |
| 1361 |
"inc-ns1:testapp:urlobject-view", |
| 1362 |
[], |
| 1363 |
{"arg1": 42, "arg2": 37}, |
| 1364 |
"inc-ns1:test-ns3", |
| 1365 |
"/ns-included1/test3/inner/42/37/", |
| 1366 |
), |
| 1367 |
( |
| 1368 |
"inc-ns1:testapp:urlobject-special-view", |
| 1369 |
[], |
| 1370 |
{}, |
| 1371 |
"inc-ns1:test-ns3", |
| 1372 |
"/ns-included1/test3/inner/+%5C$*/", |
| 1373 |
), |
| 1374 |
] |
| 1375 |
for name, args, kwargs, current_app, expected in test_urls: |
| 1376 |
with self.subTest( |
| 1377 |
name=name, args=args, kwargs=kwargs, current_app=current_app |
| 1378 |
): |
| 1379 |
self.assertEqual( |
| 1380 |
reverse(name, args=args, kwargs=kwargs, current_app=current_app), |
| 1381 |
expected, |
| 1382 |
) |
| 1383 |
|
| 1384 |
def test_current_app_no_partial_match(self): |
| 1385 |
"""current_app shouldn't be used unless it matches the whole path.""" |
| 1386 |
test_urls = [ |
| 1387 |
( |
| 1388 |
"inc-ns1:testapp:urlobject-view", |
| 1389 |
[], |
| 1390 |
{}, |
| 1391 |
"nonexistent:test-ns3", |
| 1392 |
"/ns-included1/test4/inner/", |
| 1393 |
), |
| 1394 |
( |
| 1395 |
"inc-ns1:testapp:urlobject-view", |
| 1396 |
[37, 42], |
| 1397 |
{}, |
| 1398 |
"nonexistent:test-ns3", |
| 1399 |
"/ns-included1/test4/inner/37/42/", |
| 1400 |
), |
| 1401 |
( |
| 1402 |
"inc-ns1:testapp:urlobject-view", |
| 1403 |
[], |
| 1404 |
{"arg1": 42, "arg2": 37}, |
| 1405 |
"nonexistent:test-ns3", |
| 1406 |
"/ns-included1/test4/inner/42/37/", |
| 1407 |
), |
| 1408 |
( |
| 1409 |
"inc-ns1:testapp:urlobject-special-view", |
| 1410 |
[], |
| 1411 |
{}, |
| 1412 |
"nonexistent:test-ns3", |
| 1413 |
"/ns-included1/test4/inner/+%5C$*/", |
| 1414 |
), |
| 1415 |
] |
| 1416 |
for name, args, kwargs, current_app, expected in test_urls: |
| 1417 |
with self.subTest( |
| 1418 |
name=name, args=args, kwargs=kwargs, current_app=current_app |
| 1419 |
): |
| 1420 |
self.assertEqual( |
| 1421 |
reverse(name, args=args, kwargs=kwargs, current_app=current_app), |
| 1422 |
expected, |
| 1423 |
) |
| 1424 |
|
| 1425 |
|
| 1426 |
@override_settings(ROOT_URLCONF=urlconf_outer.__name__) |
| 1427 |
class RequestURLconfTests(SimpleTestCase): |
| 1428 |
def test_urlconf(self): |
| 1429 |
response = self.client.get("/test/me/") |
| 1430 |
self.assertEqual(response.status_code, 200) |
| 1431 |
self.assertEqual( |
| 1432 |
response.content, b"outer:/test/me/,inner:/inner_urlconf/second_test/" |
| 1433 |
) |
| 1434 |
response = self.client.get("/inner_urlconf/second_test/") |
| 1435 |
self.assertEqual(response.status_code, 200) |
| 1436 |
response = self.client.get("/second_test/") |
| 1437 |
self.assertEqual(response.status_code, 404) |
| 1438 |
|
| 1439 |
@override_settings( |
| 1440 |
MIDDLEWARE=[ |
| 1441 |
"%s.ChangeURLconfMiddleware" % middleware.__name__, |
| 1442 |
] |
| 1443 |
) |
| 1444 |
def test_urlconf_overridden(self): |
| 1445 |
response = self.client.get("/test/me/") |
| 1446 |
self.assertEqual(response.status_code, 404) |
| 1447 |
response = self.client.get("/inner_urlconf/second_test/") |
| 1448 |
self.assertEqual(response.status_code, 404) |
| 1449 |
response = self.client.get("/second_test/") |
| 1450 |
self.assertEqual(response.status_code, 200) |
| 1451 |
self.assertEqual(response.content, b"outer:,inner:/second_test/") |
| 1452 |
|
| 1453 |
@override_settings( |
| 1454 |
MIDDLEWARE=[ |
| 1455 |
"%s.NullChangeURLconfMiddleware" % middleware.__name__, |
| 1456 |
] |
| 1457 |
) |
| 1458 |
def test_urlconf_overridden_with_null(self): |
| 1459 |
""" |
| 1460 |
Overriding request.urlconf with None will fall back to the default |
| 1461 |
URLconf. |
| 1462 |
""" |
| 1463 |
response = self.client.get("/test/me/") |
| 1464 |
self.assertEqual(response.status_code, 200) |
| 1465 |
self.assertEqual( |
| 1466 |
response.content, b"outer:/test/me/,inner:/inner_urlconf/second_test/" |
| 1467 |
) |
| 1468 |
response = self.client.get("/inner_urlconf/second_test/") |
| 1469 |
self.assertEqual(response.status_code, 200) |
| 1470 |
response = self.client.get("/second_test/") |
| 1471 |
self.assertEqual(response.status_code, 404) |
| 1472 |
|
| 1473 |
@override_settings( |
| 1474 |
MIDDLEWARE=[ |
| 1475 |
"%s.ChangeURLconfMiddleware" % middleware.__name__, |
| 1476 |
"%s.ReverseInnerInResponseMiddleware" % middleware.__name__, |
| 1477 |
] |
| 1478 |
) |
| 1479 |
def test_reverse_inner_in_response_middleware(self): |
| 1480 |
""" |
| 1481 |
Test reversing an URL from the *overridden* URLconf from inside |
| 1482 |
a response middleware. |
| 1483 |
""" |
| 1484 |
response = self.client.get("/second_test/") |
| 1485 |
self.assertEqual(response.status_code, 200) |
| 1486 |
self.assertEqual(response.content, b"/second_test/") |
| 1487 |
|
| 1488 |
@override_settings( |
| 1489 |
MIDDLEWARE=[ |
| 1490 |
"%s.ChangeURLconfMiddleware" % middleware.__name__, |
| 1491 |
"%s.ReverseOuterInResponseMiddleware" % middleware.__name__, |
| 1492 |
] |
| 1493 |
) |
| 1494 |
def test_reverse_outer_in_response_middleware(self): |
| 1495 |
""" |
| 1496 |
Test reversing an URL from the *default* URLconf from inside |
| 1497 |
a response middleware. |
| 1498 |
""" |
| 1499 |
msg = ( |
| 1500 |
"Reverse for 'outer' not found. 'outer' is not a valid view " |
| 1501 |
"function or pattern name." |
| 1502 |
) |
| 1503 |
with self.assertRaisesMessage(NoReverseMatch, msg): |
| 1504 |
self.client.get("/second_test/") |
| 1505 |
|
| 1506 |
@override_settings( |
| 1507 |
MIDDLEWARE=[ |
| 1508 |
"%s.ChangeURLconfMiddleware" % middleware.__name__, |
| 1509 |
"%s.ReverseInnerInStreaming" % middleware.__name__, |
| 1510 |
] |
| 1511 |
) |
| 1512 |
def test_reverse_inner_in_streaming(self): |
| 1513 |
""" |
| 1514 |
Test reversing an URL from the *overridden* URLconf from inside |
| 1515 |
a streaming response. |
| 1516 |
""" |
| 1517 |
response = self.client.get("/second_test/") |
| 1518 |
self.assertEqual(response.status_code, 200) |
| 1519 |
self.assertEqual(b"".join(response), b"/second_test/") |
| 1520 |
|
| 1521 |
@override_settings( |
| 1522 |
MIDDLEWARE=[ |
| 1523 |
"%s.ChangeURLconfMiddleware" % middleware.__name__, |
| 1524 |
"%s.ReverseOuterInStreaming" % middleware.__name__, |
| 1525 |
] |
| 1526 |
) |
| 1527 |
def test_reverse_outer_in_streaming(self): |
| 1528 |
""" |
| 1529 |
Test reversing an URL from the *default* URLconf from inside |
| 1530 |
a streaming response. |
| 1531 |
""" |
| 1532 |
message = "Reverse for 'outer' not found." |
| 1533 |
with self.assertRaisesMessage(NoReverseMatch, message): |
| 1534 |
self.client.get("/second_test/") |
| 1535 |
b"".join(self.client.get("/second_test/")) |
| 1536 |
|
| 1537 |
def test_urlconf_is_reset_after_request(self): |
| 1538 |
"""The URLconf is reset after each request.""" |
| 1539 |
self.assertIsNone(get_urlconf()) |
| 1540 |
with override_settings( |
| 1541 |
MIDDLEWARE=["%s.ChangeURLconfMiddleware" % middleware.__name__] |
| 1542 |
): |
| 1543 |
self.client.get(reverse("inner")) |
| 1544 |
self.assertIsNone(get_urlconf()) |
| 1545 |
|
| 1546 |
|
| 1547 |
class ErrorHandlerResolutionTests(SimpleTestCase): |
| 1548 |
"""Tests for handler400, handler403, handler404 and handler500""" |
| 1549 |
|
| 1550 |
def setUp(self): |
| 1551 |
urlconf = "urlpatterns_reverse.urls_error_handlers" |
| 1552 |
urlconf_callables = "urlpatterns_reverse.urls_error_handlers_callables" |
| 1553 |
self.resolver = URLResolver(RegexPattern(r"^$"), urlconf) |
| 1554 |
self.callable_resolver = URLResolver(RegexPattern(r"^$"), urlconf_callables) |
| 1555 |
|
| 1556 |
def test_named_handlers(self): |
| 1557 |
for code in [400, 403, 404, 500]: |
| 1558 |
with self.subTest(code=code): |
| 1559 |
self.assertEqual(self.resolver.resolve_error_handler(code), empty_view) |
| 1560 |
|
| 1561 |
def test_callable_handlers(self): |
| 1562 |
for code in [400, 403, 404, 500]: |
| 1563 |
with self.subTest(code=code): |
| 1564 |
self.assertEqual( |
| 1565 |
self.callable_resolver.resolve_error_handler(code), empty_view |
| 1566 |
) |
| 1567 |
|
| 1568 |
|
| 1569 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.urls_without_handlers") |
| 1570 |
class DefaultErrorHandlerTests(SimpleTestCase): |
| 1571 |
def test_default_handler(self): |
| 1572 |
"If the urls.py doesn't specify handlers, the defaults are used" |
| 1573 |
response = self.client.get("/test/") |
| 1574 |
self.assertEqual(response.status_code, 404) |
| 1575 |
|
| 1576 |
msg = "I don't think I'm getting good value for this view" |
| 1577 |
with self.assertRaisesMessage(ValueError, msg): |
| 1578 |
self.client.get("/bad_view/") |
| 1579 |
|
| 1580 |
|
| 1581 |
@override_settings(ROOT_URLCONF=None) |
| 1582 |
class NoRootUrlConfTests(SimpleTestCase): |
| 1583 |
"""Tests for handler404 and handler500 if ROOT_URLCONF is None""" |
| 1584 |
|
| 1585 |
def test_no_handler_exception(self): |
| 1586 |
msg = ( |
| 1587 |
"The included URLconf 'None' does not appear to have any patterns " |
| 1588 |
"in it. If you see the 'urlpatterns' variable with valid patterns " |
| 1589 |
"in the file then the issue is probably caused by a circular " |
| 1590 |
"import." |
| 1591 |
) |
| 1592 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 1593 |
self.client.get("/test/me/") |
| 1594 |
|
| 1595 |
|
| 1596 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.namespace_urls") |
| 1597 |
class ResolverMatchTests(SimpleTestCase): |
| 1598 |
def test_urlpattern_resolve(self): |
| 1599 |
for ( |
| 1600 |
path_, |
| 1601 |
url_name, |
| 1602 |
app_name, |
| 1603 |
namespace, |
| 1604 |
view_name, |
| 1605 |
func, |
| 1606 |
args, |
| 1607 |
kwargs, |
| 1608 |
) in resolve_test_data: |
| 1609 |
with self.subTest(path=path_): |
| 1610 |
# Legacy support for extracting "function, args, kwargs". |
| 1611 |
match_func, match_args, match_kwargs = resolve(path_) |
| 1612 |
self.assertEqual(match_func, func) |
| 1613 |
self.assertEqual(match_args, args) |
| 1614 |
self.assertEqual(match_kwargs, kwargs) |
| 1615 |
# ResolverMatch capabilities. |
| 1616 |
match = resolve(path_) |
| 1617 |
self.assertEqual(match.__class__, ResolverMatch) |
| 1618 |
self.assertEqual(match.url_name, url_name) |
| 1619 |
self.assertEqual(match.app_name, app_name) |
| 1620 |
self.assertEqual(match.namespace, namespace) |
| 1621 |
self.assertEqual(match.view_name, view_name) |
| 1622 |
self.assertEqual(match.func, func) |
| 1623 |
self.assertEqual(match.args, args) |
| 1624 |
self.assertEqual(match.kwargs, kwargs) |
| 1625 |
# and for legacy purposes: |
| 1626 |
self.assertEqual(match[0], func) |
| 1627 |
self.assertEqual(match[1], args) |
| 1628 |
self.assertEqual(match[2], kwargs) |
| 1629 |
|
| 1630 |
def test_resolver_match_on_request(self): |
| 1631 |
response = self.client.get("/resolver_match/") |
| 1632 |
resolver_match = response.resolver_match |
| 1633 |
self.assertEqual(resolver_match.url_name, "test-resolver-match") |
| 1634 |
|
| 1635 |
def test_resolver_match_on_request_before_resolution(self): |
| 1636 |
request = HttpRequest() |
| 1637 |
self.assertIsNone(request.resolver_match) |
| 1638 |
|
| 1639 |
def test_repr(self): |
| 1640 |
self.assertEqual( |
| 1641 |
repr(resolve("/no_kwargs/42/37/")), |
| 1642 |
"ResolverMatch(func=urlpatterns_reverse.views.empty_view, " |
| 1643 |
"args=('42', '37'), kwargs={}, url_name='no-kwargs', app_names=[], " |
| 1644 |
"namespaces=[], route='^no_kwargs/([0-9]+)/([0-9]+)/$')", |
| 1645 |
) |
| 1646 |
|
| 1647 |
def test_repr_extra_kwargs(self): |
| 1648 |
self.assertEqual( |
| 1649 |
repr(resolve("/mixed_args/1986/11/")), |
| 1650 |
"ResolverMatch(func=urlpatterns_reverse.views.empty_view, args=(), " |
| 1651 |
"kwargs={'arg2': '11', 'extra': True}, url_name='mixed-args', " |
| 1652 |
"app_names=[], namespaces=[], " |
| 1653 |
"route='^mixed_args/([0-9]+)/(?P<arg2>[0-9]+)/$', " |
| 1654 |
"captured_kwargs={'arg2': '11'}, extra_kwargs={'extra': True})", |
| 1655 |
) |
| 1656 |
|
| 1657 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.reverse_lazy_urls") |
| 1658 |
def test_classbased_repr(self): |
| 1659 |
self.assertEqual( |
| 1660 |
repr(resolve("/redirect/")), |
| 1661 |
"ResolverMatch(func=urlpatterns_reverse.views.LazyRedirectView, " |
| 1662 |
"args=(), kwargs={}, url_name=None, app_names=[], " |
| 1663 |
"namespaces=[], route='redirect/')", |
| 1664 |
) |
| 1665 |
|
| 1666 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.urls") |
| 1667 |
def test_repr_functools_partial(self): |
| 1668 |
tests = [ |
| 1669 |
("partial", "template.html"), |
| 1670 |
("partial_nested", "nested_partial.html"), |
| 1671 |
("partial_wrapped", "template.html"), |
| 1672 |
] |
| 1673 |
for name, template_name in tests: |
| 1674 |
with self.subTest(name=name): |
| 1675 |
func = ( |
| 1676 |
f"functools.partial({views.empty_view!r}, " |
| 1677 |
f"template_name='{template_name}')" |
| 1678 |
) |
| 1679 |
self.assertEqual( |
| 1680 |
repr(resolve(f"/{name}/")), |
| 1681 |
f"ResolverMatch(func={func}, args=(), kwargs={{}}, " |
| 1682 |
f"url_name='{name}', app_names=[], namespaces=[], " |
| 1683 |
f"route='{name}/')", |
| 1684 |
) |
| 1685 |
|
| 1686 |
@override_settings(ROOT_URLCONF="urlpatterns.path_urls") |
| 1687 |
def test_pickling(self): |
| 1688 |
msg = "Cannot pickle ResolverMatch." |
| 1689 |
with self.assertRaisesMessage(pickle.PicklingError, msg): |
| 1690 |
pickle.dumps(resolve("/users/")) |
| 1691 |
|
| 1692 |
|
| 1693 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.erroneous_urls") |
| 1694 |
class ErroneousViewTests(SimpleTestCase): |
| 1695 |
def test_noncallable_view(self): |
| 1696 |
# View is not a callable (explicit import; arbitrary Python object) |
| 1697 |
with self.assertRaisesMessage(TypeError, "view must be a callable"): |
| 1698 |
path("uncallable-object/", views.uncallable) |
| 1699 |
|
| 1700 |
def test_invalid_regex(self): |
| 1701 |
# Regex contains an error (refs #6170) |
| 1702 |
msg = '(regex_error/$" is not a valid regular expression' |
| 1703 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 1704 |
reverse(views.empty_view) |
| 1705 |
|
| 1706 |
|
| 1707 |
class ViewLoadingTests(SimpleTestCase): |
| 1708 |
def test_view_loading(self): |
| 1709 |
self.assertEqual( |
| 1710 |
get_callable("urlpatterns_reverse.views.empty_view"), empty_view |
| 1711 |
) |
| 1712 |
self.assertEqual(get_callable(empty_view), empty_view) |
| 1713 |
|
| 1714 |
def test_view_does_not_exist(self): |
| 1715 |
msg = "View does not exist in module urlpatterns_reverse.views." |
| 1716 |
with self.assertRaisesMessage(ViewDoesNotExist, msg): |
| 1717 |
get_callable("urlpatterns_reverse.views.i_should_not_exist") |
| 1718 |
|
| 1719 |
def test_attributeerror_not_hidden(self): |
| 1720 |
msg = "I am here to confuse django.urls.get_callable" |
| 1721 |
with self.assertRaisesMessage(AttributeError, msg): |
| 1722 |
get_callable("urlpatterns_reverse.views_broken.i_am_broken") |
| 1723 |
|
| 1724 |
def test_non_string_value(self): |
| 1725 |
msg = "'1' is not a callable or a dot-notation path" |
| 1726 |
with self.assertRaisesMessage(ViewDoesNotExist, msg): |
| 1727 |
get_callable(1) |
| 1728 |
|
| 1729 |
def test_string_without_dot(self): |
| 1730 |
msg = "Could not import 'test'. The path must be fully qualified." |
| 1731 |
with self.assertRaisesMessage(ImportError, msg): |
| 1732 |
get_callable("test") |
| 1733 |
|
| 1734 |
def test_module_does_not_exist(self): |
| 1735 |
with self.assertRaisesMessage(ImportError, "No module named 'foo'"): |
| 1736 |
get_callable("foo.bar") |
| 1737 |
|
| 1738 |
def test_parent_module_does_not_exist(self): |
| 1739 |
msg = "Parent module urlpatterns_reverse.foo does not exist." |
| 1740 |
with self.assertRaisesMessage(ViewDoesNotExist, msg): |
| 1741 |
get_callable("urlpatterns_reverse.foo.bar") |
| 1742 |
|
| 1743 |
def test_not_callable(self): |
| 1744 |
msg = ( |
| 1745 |
"Could not import 'urlpatterns_reverse.tests.resolve_test_data'. " |
| 1746 |
"View is not callable." |
| 1747 |
) |
| 1748 |
with self.assertRaisesMessage(ViewDoesNotExist, msg): |
| 1749 |
get_callable("urlpatterns_reverse.tests.resolve_test_data") |
| 1750 |
|
| 1751 |
|
| 1752 |
class IncludeTests(SimpleTestCase): |
| 1753 |
url_patterns = [ |
| 1754 |
path("inner/", views.empty_view, name="urlobject-view"), |
| 1755 |
re_path( |
| 1756 |
r"^inner/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$", |
| 1757 |
views.empty_view, |
| 1758 |
name="urlobject-view", |
| 1759 |
), |
| 1760 |
re_path(r"^inner/\+\\\$\*/$", views.empty_view, name="urlobject-special-view"), |
| 1761 |
] |
| 1762 |
app_urls = URLObject("inc-app") |
| 1763 |
|
| 1764 |
def test_include_urls(self): |
| 1765 |
self.assertEqual(include(self.url_patterns), (self.url_patterns, None, None)) |
| 1766 |
|
| 1767 |
def test_include_namespace(self): |
| 1768 |
msg = ( |
| 1769 |
"Specifying a namespace in include() without providing an " |
| 1770 |
"app_name is not supported." |
| 1771 |
) |
| 1772 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 1773 |
include(self.url_patterns, "namespace") |
| 1774 |
|
| 1775 |
def test_include_4_tuple(self): |
| 1776 |
msg = "Passing a 4-tuple to include() is not supported." |
| 1777 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 1778 |
include((self.url_patterns, "app_name", "namespace", "blah")) |
| 1779 |
|
| 1780 |
def test_include_3_tuple(self): |
| 1781 |
msg = "Passing a 3-tuple to include() is not supported." |
| 1782 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 1783 |
include((self.url_patterns, "app_name", "namespace")) |
| 1784 |
|
| 1785 |
def test_include_3_tuple_namespace(self): |
| 1786 |
msg = ( |
| 1787 |
"Cannot override the namespace for a dynamic module that provides a " |
| 1788 |
"namespace." |
| 1789 |
) |
| 1790 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 1791 |
include((self.url_patterns, "app_name", "namespace"), "namespace") |
| 1792 |
|
| 1793 |
def test_include_2_tuple(self): |
| 1794 |
self.assertEqual( |
| 1795 |
include((self.url_patterns, "app_name")), |
| 1796 |
(self.url_patterns, "app_name", "app_name"), |
| 1797 |
) |
| 1798 |
|
| 1799 |
def test_include_2_tuple_namespace(self): |
| 1800 |
self.assertEqual( |
| 1801 |
include((self.url_patterns, "app_name"), namespace="namespace"), |
| 1802 |
(self.url_patterns, "app_name", "namespace"), |
| 1803 |
) |
| 1804 |
|
| 1805 |
def test_include_app_name(self): |
| 1806 |
self.assertEqual(include(self.app_urls), (self.app_urls, "inc-app", "inc-app")) |
| 1807 |
|
| 1808 |
def test_include_app_name_namespace(self): |
| 1809 |
self.assertEqual( |
| 1810 |
include(self.app_urls, "namespace"), (self.app_urls, "inc-app", "namespace") |
| 1811 |
) |
| 1812 |
|
| 1813 |
|
| 1814 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.urls") |
| 1815 |
class LookaheadTests(SimpleTestCase): |
| 1816 |
def test_valid_resolve(self): |
| 1817 |
test_urls = [ |
| 1818 |
"/lookahead-/a-city/", |
| 1819 |
"/lookbehind-/a-city/", |
| 1820 |
"/lookahead+/a-city/", |
| 1821 |
"/lookbehind+/a-city/", |
| 1822 |
] |
| 1823 |
for test_url in test_urls: |
| 1824 |
with self.subTest(url=test_url): |
| 1825 |
self.assertEqual(resolve(test_url).kwargs, {"city": "a-city"}) |
| 1826 |
|
| 1827 |
def test_invalid_resolve(self): |
| 1828 |
test_urls = [ |
| 1829 |
"/lookahead-/not-a-city/", |
| 1830 |
"/lookbehind-/not-a-city/", |
| 1831 |
"/lookahead+/other-city/", |
| 1832 |
"/lookbehind+/other-city/", |
| 1833 |
] |
| 1834 |
for test_url in test_urls: |
| 1835 |
with self.subTest(url=test_url): |
| 1836 |
with self.assertRaises(Resolver404): |
| 1837 |
resolve(test_url) |
| 1838 |
|
| 1839 |
def test_valid_reverse(self): |
| 1840 |
test_urls = [ |
| 1841 |
("lookahead-positive", {"city": "a-city"}, "/lookahead+/a-city/"), |
| 1842 |
("lookahead-negative", {"city": "a-city"}, "/lookahead-/a-city/"), |
| 1843 |
("lookbehind-positive", {"city": "a-city"}, "/lookbehind+/a-city/"), |
| 1844 |
("lookbehind-negative", {"city": "a-city"}, "/lookbehind-/a-city/"), |
| 1845 |
] |
| 1846 |
for name, kwargs, expected in test_urls: |
| 1847 |
with self.subTest(name=name, kwargs=kwargs): |
| 1848 |
self.assertEqual(reverse(name, kwargs=kwargs), expected) |
| 1849 |
|
| 1850 |
def test_invalid_reverse(self): |
| 1851 |
test_urls = [ |
| 1852 |
("lookahead-positive", {"city": "other-city"}), |
| 1853 |
("lookahead-negative", {"city": "not-a-city"}), |
| 1854 |
("lookbehind-positive", {"city": "other-city"}), |
| 1855 |
("lookbehind-negative", {"city": "not-a-city"}), |
| 1856 |
] |
| 1857 |
for name, kwargs in test_urls: |
| 1858 |
with self.subTest(name=name, kwargs=kwargs): |
| 1859 |
with self.assertRaises(NoReverseMatch): |
| 1860 |
reverse(name, kwargs=kwargs) |
| 1861 |
|
| 1862 |
|
| 1863 |
@override_settings(ROOT_URLCONF="urlpatterns_reverse.urls") |
| 1864 |
class ReverseResolvedTests(SimpleTestCase): |
| 1865 |
def test_rereverse(self): |
| 1866 |
match = resolve("/resolved/12/") |
| 1867 |
self.assertEqual( |
| 1868 |
reverse(match.url_name, args=match.args, kwargs=match.kwargs), |
| 1869 |
"/resolved/12/", |
| 1870 |
) |
| 1871 |
match = resolve("/resolved-overridden/12/url/") |
| 1872 |
self.assertEqual( |
| 1873 |
reverse(match.url_name, args=match.args, kwargs=match.captured_kwargs), |
| 1874 |
"/resolved-overridden/12/url/", |
| 1875 |
) |