Debian Codegraph @

tests/i18n/patterns/tests.py

raw
1 import os
2
3 from django.conf import settings
4 from django.core.exceptions import ImproperlyConfigured
5 from django.http import HttpResponse, HttpResponsePermanentRedirect
6 from django.middleware.locale import LocaleMiddleware
7 from django.template import Context, Template
8 from django.test import SimpleTestCase, override_settings
9 from django.test.client import RequestFactory
10 from django.test.utils import override_script_prefix
11 from django.urls import clear_url_caches, resolve, reverse, translate_url
12 from django.utils import translation
13
14
15 class PermanentRedirectLocaleMiddleWare(LocaleMiddleware):
16 response_redirect_class = HttpResponsePermanentRedirect
17
18
19 @override_settings(
20 USE_I18N=True,
21 LOCALE_PATHS=[
22 os.path.join(os.path.dirname(__file__), "locale"),
23 ],
24 LANGUAGE_CODE="en-us",
25 LANGUAGES=[
26 ("nl", "Dutch"),
27 ("en", "English"),
28 ("pt-br", "Brazilian Portuguese"),
29 ],
30 MIDDLEWARE=[
31 "django.middleware.locale.LocaleMiddleware",
32 "django.middleware.common.CommonMiddleware",
33 ],
34 ROOT_URLCONF="i18n.patterns.urls.default",
35 TEMPLATES=[
36 {
37 "BACKEND": "django.template.backends.django.DjangoTemplates",
38 "DIRS": [os.path.join(os.path.dirname(__file__), "templates")],
39 "OPTIONS": {
40 "context_processors": [
41 "django.template.context_processors.i18n",
42 ],
43 },
44 }
45 ],
46 )
47 class URLTestCaseBase(SimpleTestCase):
48 """
49 TestCase base-class for the URL tests.
50 """
51
52 def setUp(self):
53 # Make sure the cache is empty before we are doing our tests.
54 clear_url_caches()
55 # Make sure we will leave an empty cache for other testcases.
56 self.addCleanup(clear_url_caches)
57
58
59 class URLPrefixTests(URLTestCaseBase):
60 """
61 Tests if the `i18n_patterns` is adding the prefix correctly.
62 """
63
64 def test_not_prefixed(self):
65 with translation.override("en"):
66 self.assertEqual(reverse("not-prefixed"), "/not-prefixed/")
67 self.assertEqual(
68 reverse("not-prefixed-included-url"), "/not-prefixed-include/foo/"
69 )
70 with translation.override("nl"):
71 self.assertEqual(reverse("not-prefixed"), "/not-prefixed/")
72 self.assertEqual(
73 reverse("not-prefixed-included-url"), "/not-prefixed-include/foo/"
74 )
75
76 def test_prefixed(self):
77 with translation.override("en"):
78 self.assertEqual(reverse("prefixed"), "/en/prefixed/")
79 with translation.override("nl"):
80 self.assertEqual(reverse("prefixed"), "/nl/prefixed/")
81 with translation.override(None):
82 self.assertEqual(
83 reverse("prefixed"), "/%s/prefixed/" % settings.LANGUAGE_CODE
84 )
85
86 @override_settings(ROOT_URLCONF="i18n.patterns.urls.wrong")
87 def test_invalid_prefix_use(self):
88 msg = "Using i18n_patterns in an included URLconf is not allowed."
89 with self.assertRaisesMessage(ImproperlyConfigured, msg):
90 reverse("account:register")
91
92
93 @override_settings(ROOT_URLCONF="i18n.patterns.urls.disabled")
94 class URLDisabledTests(URLTestCaseBase):
95 @override_settings(USE_I18N=False)
96 def test_prefixed_i18n_disabled(self):
97 with translation.override("en"):
98 self.assertEqual(reverse("prefixed"), "/prefixed/")
99 with translation.override("nl"):
100 self.assertEqual(reverse("prefixed"), "/prefixed/")
101
102
103 class RequestURLConfTests(SimpleTestCase):
104 @override_settings(ROOT_URLCONF="i18n.patterns.urls.path_unused")
105 def test_request_urlconf_considered(self):
106 request = RequestFactory().get("/nl/")
107 request.urlconf = "i18n.patterns.urls.default"
108 middleware = LocaleMiddleware(lambda req: HttpResponse())
109 with translation.override("nl"):
110 middleware.process_request(request)
111 self.assertEqual(request.LANGUAGE_CODE, "nl")
112
113
114 @override_settings(ROOT_URLCONF="i18n.patterns.urls.path_unused")
115 class PathUnusedTests(URLTestCaseBase):
116 """
117 If no i18n_patterns is used in root URLconfs, then no language activation
118 activation happens based on url prefix.
119 """
120
121 def test_no_lang_activate(self):
122 response = self.client.get("/nl/foo/")
123 self.assertEqual(response.status_code, 200)
124 self.assertEqual(response.headers["content-language"], "en")
125 self.assertEqual(response.context["LANGUAGE_CODE"], "en")
126
127
128 class URLTranslationTests(URLTestCaseBase):
129 """
130 Tests if the pattern-strings are translated correctly (within the
131 `i18n_patterns` and the normal `patterns` function).
132 """
133
134 def test_no_prefix_translated(self):
135 with translation.override("en"):
136 self.assertEqual(reverse("no-prefix-translated"), "/translated/")
137 self.assertEqual(
138 reverse("no-prefix-translated-regex"), "/translated-regex/"
139 )
140 self.assertEqual(
141 reverse("no-prefix-translated-slug", kwargs={"slug": "yeah"}),
142 "/translated/yeah/",
143 )
144
145 with translation.override("nl"):
146 self.assertEqual(reverse("no-prefix-translated"), "/vertaald/")
147 self.assertEqual(reverse("no-prefix-translated-regex"), "/vertaald-regex/")
148 self.assertEqual(
149 reverse("no-prefix-translated-slug", kwargs={"slug": "yeah"}),
150 "/vertaald/yeah/",
151 )
152
153 with translation.override("pt-br"):
154 self.assertEqual(reverse("no-prefix-translated"), "/traduzidos/")
155 self.assertEqual(
156 reverse("no-prefix-translated-regex"), "/traduzidos-regex/"
157 )
158 self.assertEqual(
159 reverse("no-prefix-translated-slug", kwargs={"slug": "yeah"}),
160 "/traduzidos/yeah/",
161 )
162
163 def test_users_url(self):
164 with translation.override("en"):
165 self.assertEqual(reverse("users"), "/en/users/")
166
167 with translation.override("nl"):
168 self.assertEqual(reverse("users"), "/nl/gebruikers/")
169 self.assertEqual(reverse("prefixed_xml"), "/nl/prefixed.xml")
170
171 with translation.override("pt-br"):
172 self.assertEqual(reverse("users"), "/pt-br/usuarios/")
173
174 def test_translate_url_utility(self):
175 with translation.override("en"):
176 self.assertEqual(
177 translate_url("/en/nonexistent/", "nl"), "/en/nonexistent/"
178 )
179 self.assertEqual(translate_url("/en/users/", "nl"), "/nl/gebruikers/")
180 # Namespaced URL
181 self.assertEqual(
182 translate_url("/en/account/register/", "nl"), "/nl/profiel/registreren/"
183 )
184 # path() URL pattern
185 self.assertEqual(
186 translate_url("/en/account/register-as-path/", "nl"),
187 "/nl/profiel/registreren-als-pad/",
188 )
189 self.assertEqual(translation.get_language(), "en")
190 # re_path() URL with parameters.
191 self.assertEqual(
192 translate_url("/en/with-arguments/regular-argument/", "nl"),
193 "/nl/with-arguments/regular-argument/",
194 )
195 self.assertEqual(
196 translate_url(
197 "/en/with-arguments/regular-argument/optional.html", "nl"
198 ),
199 "/nl/with-arguments/regular-argument/optional.html",
200 )
201 # path() URL with parameter.
202 self.assertEqual(
203 translate_url("/en/path-with-arguments/regular-argument/", "nl"),
204 "/nl/path-with-arguments/regular-argument/",
205 )
206
207 with translation.override("nl"):
208 self.assertEqual(translate_url("/nl/gebruikers/", "en"), "/en/users/")
209 self.assertEqual(translation.get_language(), "nl")
210
211 def test_reverse_translated_with_captured_kwargs(self):
212 with translation.override("en"):
213 match = resolve("/translated/apo/")
214 # Links to the same page in other languages.
215 tests = [
216 ("nl", "/vertaald/apo/"),
217 ("pt-br", "/traduzidos/apo/"),
218 ]
219 for lang, expected_link in tests:
220 with translation.override(lang):
221 self.assertEqual(
222 reverse(
223 match.url_name, args=match.args, kwargs=match.captured_kwargs
224 ),
225 expected_link,
226 )
227
228 def test_locale_not_interepreted_as_regex(self):
229 with translation.override("e("):
230 # Would previously error:
231 # re.error: missing ), unterminated subpattern at position 1
232 reverse("users")
233
234
235 class URLNamespaceTests(URLTestCaseBase):
236 """
237 Tests if the translations are still working within namespaces.
238 """
239
240 def test_account_register(self):
241 with translation.override("en"):
242 self.assertEqual(reverse("account:register"), "/en/account/register/")
243 self.assertEqual(
244 reverse("account:register-as-path"), "/en/account/register-as-path/"
245 )
246
247 with translation.override("nl"):
248 self.assertEqual(reverse("account:register"), "/nl/profiel/registreren/")
249 self.assertEqual(
250 reverse("account:register-as-path"), "/nl/profiel/registreren-als-pad/"
251 )
252
253
254 class URLRedirectTests(URLTestCaseBase):
255 """
256 Tests if the user gets redirected to the right URL when there is no
257 language-prefix in the request URL.
258 """
259
260 def test_no_prefix_response(self):
261 response = self.client.get("/not-prefixed/")
262 self.assertEqual(response.status_code, 200)
263
264 def test_en_redirect(self):
265 response = self.client.get(
266 "/account/register/", headers={"accept-language": "en"}
267 )
268 self.assertRedirects(response, "/en/account/register/")
269
270 response = self.client.get(response.headers["location"])
271 self.assertEqual(response.status_code, 200)
272
273 def test_en_redirect_wrong_url(self):
274 response = self.client.get(
275 "/profiel/registreren/", headers={"accept-language": "en"}
276 )
277 self.assertEqual(response.status_code, 404)
278
279 def test_nl_redirect(self):
280 response = self.client.get(
281 "/profiel/registreren/", headers={"accept-language": "nl"}
282 )
283 self.assertRedirects(response, "/nl/profiel/registreren/")
284
285 response = self.client.get(response.headers["location"])
286 self.assertEqual(response.status_code, 200)
287
288 def test_nl_redirect_wrong_url(self):
289 response = self.client.get(
290 "/account/register/", headers={"accept-language": "nl"}
291 )
292 self.assertEqual(response.status_code, 404)
293
294 def test_pt_br_redirect(self):
295 response = self.client.get(
296 "/conta/registre-se/", headers={"accept-language": "pt-br"}
297 )
298 self.assertRedirects(response, "/pt-br/conta/registre-se/")
299
300 response = self.client.get(response.headers["location"])
301 self.assertEqual(response.status_code, 200)
302
303 def test_pl_pl_redirect(self):
304 # language from outside of the supported LANGUAGES list
305 response = self.client.get(
306 "/account/register/", headers={"accept-language": "pl-pl"}
307 )
308 self.assertRedirects(response, "/en/account/register/")
309
310 response = self.client.get(response.headers["location"])
311 self.assertEqual(response.status_code, 200)
312
313 @override_settings(
314 MIDDLEWARE=[
315 "i18n.patterns.tests.PermanentRedirectLocaleMiddleWare",
316 "django.middleware.common.CommonMiddleware",
317 ],
318 )
319 def test_custom_redirect_class(self):
320 response = self.client.get(
321 "/account/register/", headers={"accept-language": "en"}
322 )
323 self.assertRedirects(response, "/en/account/register/", 301)
324
325
326 class URLVaryAcceptLanguageTests(URLTestCaseBase):
327 """
328 'Accept-Language' is not added to the Vary header when using prefixed URLs.
329 """
330
331 def test_no_prefix_response(self):
332 response = self.client.get("/not-prefixed/")
333 self.assertEqual(response.status_code, 200)
334 self.assertEqual(response.get("Vary"), "Accept-Language")
335
336 def test_en_redirect(self):
337 """
338 The redirect to a prefixed URL depends on 'Accept-Language' and
339 'Cookie', but once prefixed no header is set.
340 """
341 response = self.client.get(
342 "/account/register/", headers={"accept-language": "en"}
343 )
344 self.assertRedirects(response, "/en/account/register/")
345 self.assertEqual(response.get("Vary"), "Accept-Language, Cookie")
346
347 response = self.client.get(response.headers["location"])
348 self.assertEqual(response.status_code, 200)
349 self.assertFalse(response.get("Vary"))
350
351
352 class URLRedirectWithoutTrailingSlashTests(URLTestCaseBase):
353 """
354 Tests the redirect when the requested URL doesn't end with a slash
355 (`settings.APPEND_SLASH=True`).
356 """
357
358 def test_not_prefixed_redirect(self):
359 response = self.client.get("/not-prefixed", headers={"accept-language": "en"})
360 self.assertRedirects(response, "/not-prefixed/", 301)
361
362 def test_en_redirect(self):
363 response = self.client.get(
364 "/account/register", headers={"accept-language": "en"}, follow=True
365 )
366 # We only want one redirect, bypassing CommonMiddleware
367 self.assertEqual(response.redirect_chain, [("/en/account/register/", 302)])
368 self.assertRedirects(response, "/en/account/register/", 302)
369
370 response = self.client.get(
371 "/prefixed.xml", headers={"accept-language": "en"}, follow=True
372 )
373 self.assertRedirects(response, "/en/prefixed.xml", 302)
374
375
376 class URLRedirectWithoutTrailingSlashSettingTests(URLTestCaseBase):
377 """
378 Tests the redirect when the requested URL doesn't end with a slash
379 (`settings.APPEND_SLASH=False`).
380 """
381
382 @override_settings(APPEND_SLASH=False)
383 def test_not_prefixed_redirect(self):
384 response = self.client.get("/not-prefixed", headers={"accept-language": "en"})
385 self.assertEqual(response.status_code, 404)
386
387 @override_settings(APPEND_SLASH=False)
388 def test_en_redirect(self):
389 response = self.client.get(
390 "/account/register-without-slash", headers={"accept-language": "en"}
391 )
392 self.assertRedirects(response, "/en/account/register-without-slash", 302)
393
394 response = self.client.get(response.headers["location"])
395 self.assertEqual(response.status_code, 200)
396
397
398 class URLResponseTests(URLTestCaseBase):
399 """Tests if the response has the correct language code."""
400
401 def test_not_prefixed_with_prefix(self):
402 response = self.client.get("/en/not-prefixed/")
403 self.assertEqual(response.status_code, 404)
404
405 def test_en_url(self):
406 response = self.client.get("/en/account/register/")
407 self.assertEqual(response.status_code, 200)
408 self.assertEqual(response.headers["content-language"], "en")
409 self.assertEqual(response.context["LANGUAGE_CODE"], "en")
410
411 def test_nl_url(self):
412 response = self.client.get("/nl/profiel/registreren/")
413 self.assertEqual(response.status_code, 200)
414 self.assertEqual(response.headers["content-language"], "nl")
415 self.assertEqual(response.context["LANGUAGE_CODE"], "nl")
416
417 def test_wrong_en_prefix(self):
418 response = self.client.get("/en/profiel/registreren/")
419 self.assertEqual(response.status_code, 404)
420
421 def test_wrong_nl_prefix(self):
422 response = self.client.get("/nl/account/register/")
423 self.assertEqual(response.status_code, 404)
424
425 def test_pt_br_url(self):
426 response = self.client.get("/pt-br/conta/registre-se/")
427 self.assertEqual(response.status_code, 200)
428 self.assertEqual(response.headers["content-language"], "pt-br")
429 self.assertEqual(response.context["LANGUAGE_CODE"], "pt-br")
430
431 def test_en_path(self):
432 response = self.client.get("/en/account/register-as-path/")
433 self.assertEqual(response.status_code, 200)
434 self.assertEqual(response.headers["content-language"], "en")
435 self.assertEqual(response.context["LANGUAGE_CODE"], "en")
436
437 def test_nl_path(self):
438 response = self.client.get("/nl/profiel/registreren-als-pad/")
439 self.assertEqual(response.status_code, 200)
440 self.assertEqual(response.headers["content-language"], "nl")
441 self.assertEqual(response.context["LANGUAGE_CODE"], "nl")
442
443
444 @override_settings(ROOT_URLCONF="i18n.urls_default_unprefixed", LANGUAGE_CODE="nl")
445 class URLPrefixedFalseTranslatedTests(URLTestCaseBase):
446 def test_translated_path_unprefixed_language_other_than_accepted_header(self):
447 response = self.client.get("/gebruikers/", headers={"accept-language": "en"})
448 self.assertEqual(response.status_code, 200)
449
450 def test_translated_path_unprefixed_language_other_than_cookie_language(self):
451 self.client.cookies.load({settings.LANGUAGE_COOKIE_NAME: "en"})
452 response = self.client.get("/gebruikers/")
453 self.assertEqual(response.status_code, 200)
454
455 def test_translated_path_prefixed_language_other_than_accepted_header(self):
456 response = self.client.get("/en/users/", headers={"accept-language": "nl"})
457 self.assertEqual(response.status_code, 200)
458
459 def test_translated_path_prefixed_language_other_than_cookie_language(self):
460 self.client.cookies.load({settings.LANGUAGE_COOKIE_NAME: "nl"})
461 response = self.client.get("/en/users/")
462 self.assertEqual(response.status_code, 200)
463
464
465 class URLRedirectWithScriptAliasTests(URLTestCaseBase):
466 """
467 #21579 - LocaleMiddleware should respect the script prefix.
468 """
469
470 def test_language_prefix_with_script_prefix(self):
471 prefix = "/script_prefix"
472 with override_script_prefix(prefix):
473 response = self.client.get(
474 "/prefixed/", headers={"accept-language": "en"}, SCRIPT_NAME=prefix
475 )
476 self.assertRedirects(
477 response, "%s/en/prefixed/" % prefix, target_status_code=404
478 )
479
480
481 class URLTagTests(URLTestCaseBase):
482 """
483 Test if the language tag works.
484 """
485
486 def test_strings_only(self):
487 t = Template("""{% load i18n %}
488 {% language 'nl' %}{% url 'no-prefix-translated' %}{% endlanguage %}
489 {% language 'pt-br' %}{% url 'no-prefix-translated' %}{% endlanguage %}""")
490 self.assertEqual(
491 t.render(Context({})).strip().split(), ["/vertaald/", "/traduzidos/"]
492 )
493
494 def test_context(self):
495 ctx = Context({"lang1": "nl", "lang2": "pt-br"})
496 tpl = Template("""{% load i18n %}
497 {% language lang1 %}{% url 'no-prefix-translated' %}{% endlanguage %}
498 {% language lang2 %}{% url 'no-prefix-translated' %}{% endlanguage %}""")
499 self.assertEqual(
500 tpl.render(ctx).strip().split(), ["/vertaald/", "/traduzidos/"]
501 )
502
503 def test_args(self):
504 tpl = Template("""
505 {% load i18n %}
506 {% language 'nl' %}
507 {% url 'no-prefix-translated-slug' 'apo' %}{% endlanguage %}
508 {% language 'pt-br' %}
509 {% url 'no-prefix-translated-slug' 'apo' %}{% endlanguage %}
510 """)
511 self.assertEqual(
512 tpl.render(Context({})).strip().split(),
513 ["/vertaald/apo/", "/traduzidos/apo/"],
514 )
515
516 def test_kwargs(self):
517 tpl = Template("""
518 {% load i18n %}
519 {% language 'nl' %}
520 {% url 'no-prefix-translated-slug' slug='apo' %}{% endlanguage %}
521 {% language 'pt-br' %}
522 {% url 'no-prefix-translated-slug' slug='apo' %}{% endlanguage %}
523 """)
524 self.assertEqual(
525 tpl.render(Context({})).strip().split(),
526 ["/vertaald/apo/", "/traduzidos/apo/"],
527 )