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. 

  56.     def tearDown(self):

  57.         # Make sure we will leave an empty cache for other testcases.

  58.         clear_url_caches()

  59. 

  60. 

  61. class URLPrefixTests(URLTestCaseBase):

  62.     """

  63.     Tests if the `i18n_patterns` is adding the prefix correctly.

  64.     """

  65. 

  66.     def test_not_prefixed(self):

  67.         with translation.override("en"):

  68.             self.assertEqual(reverse("not-prefixed"), "/not-prefixed/")

  69.             self.assertEqual(

  70.                 reverse("not-prefixed-included-url"), "/not-prefixed-include/foo/"

  71.             )

  72.         with translation.override("nl"):

  73.             self.assertEqual(reverse("not-prefixed"), "/not-prefixed/")

  74.             self.assertEqual(

  75.                 reverse("not-prefixed-included-url"), "/not-prefixed-include/foo/"

  76.             )

  77. 

  78.     def test_prefixed(self):

  79.         with translation.override("en"):

  80.             self.assertEqual(reverse("prefixed"), "/en/prefixed/")

  81.         with translation.override("nl"):

  82.             self.assertEqual(reverse("prefixed"), "/nl/prefixed/")

  83.         with translation.override(None):

  84.             self.assertEqual(

  85.                 reverse("prefixed"), "/%s/prefixed/" % settings.LANGUAGE_CODE

  86.             )

  87. 

  88.     @override_settings(ROOT_URLCONF="i18n.patterns.urls.wrong")

  89.     def test_invalid_prefix_use(self):

  90.         msg = "Using i18n_patterns in an included URLconf is not allowed."

  91.         with self.assertRaisesMessage(ImproperlyConfigured, msg):

  92.             reverse("account:register")

  93. 

  94. 

  95. @override_settings(ROOT_URLCONF="i18n.patterns.urls.disabled")

  96. class URLDisabledTests(URLTestCaseBase):

  97.     @override_settings(USE_I18N=False)

  98.     def test_prefixed_i18n_disabled(self):

  99.         with translation.override("en"):

  100.             self.assertEqual(reverse("prefixed"), "/prefixed/")

  101.         with translation.override("nl"):

  102.             self.assertEqual(reverse("prefixed"), "/prefixed/")

  103. 

  104. 

  105. class RequestURLConfTests(SimpleTestCase):

  106.     @override_settings(ROOT_URLCONF="i18n.patterns.urls.path_unused")

  107.     def test_request_urlconf_considered(self):

  108.         request = RequestFactory().get("/nl/")

  109.         request.urlconf = "i18n.patterns.urls.default"

  110.         middleware = LocaleMiddleware(lambda req: HttpResponse())

  111.         with translation.override("nl"):

  112.             middleware.process_request(request)

  113.         self.assertEqual(request.LANGUAGE_CODE, "nl")

  114. 

  115. 

  116. @override_settings(ROOT_URLCONF="i18n.patterns.urls.path_unused")

  117. class PathUnusedTests(URLTestCaseBase):

  118.     """

  119.     If no i18n_patterns is used in root URLconfs, then no language activation

  120.     activation happens based on url prefix.

  121.     """

  122. 

  123.     def test_no_lang_activate(self):

  124.         response = self.client.get("/nl/foo/")

  125.         self.assertEqual(response.status_code, 200)

  126.         self.assertEqual(response.headers["content-language"], "en")

  127.         self.assertEqual(response.context["LANGUAGE_CODE"], "en")

  128. 

  129. 

  130. class URLTranslationTests(URLTestCaseBase):

  131.     """

  132.     Tests if the pattern-strings are translated correctly (within the

  133.     `i18n_patterns` and the normal `patterns` function).

  134.     """

  135. 

  136.     def test_no_prefix_translated(self):

  137.         with translation.override("en"):

  138.             self.assertEqual(reverse("no-prefix-translated"), "/translated/")

  139.             self.assertEqual(

  140.                 reverse("no-prefix-translated-slug", kwargs={"slug": "yeah"}),

  141.                 "/translated/yeah/",

  142.             )

  143. 

  144.         with translation.override("nl"):

  145.             self.assertEqual(reverse("no-prefix-translated"), "/vertaald/")

  146.             self.assertEqual(

  147.                 reverse("no-prefix-translated-slug", kwargs={"slug": "yeah"}),

  148.                 "/vertaald/yeah/",

  149.             )

  150. 

  151.         with translation.override("pt-br"):

  152.             self.assertEqual(reverse("no-prefix-translated"), "/traduzidos/")

  153.             self.assertEqual(

  154.                 reverse("no-prefix-translated-slug", kwargs={"slug": "yeah"}),

  155.                 "/traduzidos/yeah/",

  156.             )

  157. 

  158.     def test_users_url(self):

  159.         with translation.override("en"):

  160.             self.assertEqual(reverse("users"), "/en/users/")

  161. 

  162.         with translation.override("nl"):

  163.             self.assertEqual(reverse("users"), "/nl/gebruikers/")

  164.             self.assertEqual(reverse("prefixed_xml"), "/nl/prefixed.xml")

  165. 

  166.         with translation.override("pt-br"):

  167.             self.assertEqual(reverse("users"), "/pt-br/usuarios/")

  168. 

  169.     def test_translate_url_utility(self):

  170.         with translation.override("en"):

  171.             self.assertEqual(

  172.                 translate_url("/en/nonexistent/", "nl"), "/en/nonexistent/"

  173.             )

  174.             self.assertEqual(translate_url("/en/users/", "nl"), "/nl/gebruikers/")

  175.             # Namespaced URL

  176.             self.assertEqual(

  177.                 translate_url("/en/account/register/", "nl"), "/nl/profiel/registreren/"

  178.             )

  179.             # path() URL pattern

  180.             self.assertEqual(

  181.                 translate_url("/en/account/register-as-path/", "nl"),

  182.                 "/nl/profiel/registreren-als-pad/",

  183.             )

  184.             self.assertEqual(translation.get_language(), "en")

  185.             # URL with parameters.

  186.             self.assertEqual(

  187.                 translate_url("/en/with-arguments/regular-argument/", "nl"),

  188.                 "/nl/with-arguments/regular-argument/",

  189.             )

  190.             self.assertEqual(

  191.                 translate_url(

  192.                     "/en/with-arguments/regular-argument/optional.html", "nl"

  193.                 ),

  194.                 "/nl/with-arguments/regular-argument/optional.html",

  195.             )

  196. 

  197.         with translation.override("nl"):

  198.             self.assertEqual(translate_url("/nl/gebruikers/", "en"), "/en/users/")

  199.             self.assertEqual(translation.get_language(), "nl")

  200. 

  201.     def test_reverse_translated_with_captured_kwargs(self):

  202.         with translation.override("en"):

  203.             match = resolve("/translated/apo/")

  204.         # Links to the same page in other languages.

  205.         tests = [

  206.             ("nl", "/vertaald/apo/"),

  207.             ("pt-br", "/traduzidos/apo/"),

  208.         ]

  209.         for lang, expected_link in tests:

  210.             with translation.override(lang):

  211.                 self.assertEqual(

  212.                     reverse(

  213.                         match.url_name, args=match.args, kwargs=match.captured_kwargs

  214.                     ),

  215.                     expected_link,

  216.                 )

  217. 

  218.     def test_locale_not_interepreted_as_regex(self):

  219.         with translation.override("e("):

  220.             # Would previously error:

  221.             # re.error: missing ), unterminated subpattern at position 1

  222.             reverse("users")

  223. 

  224. 

  225. class URLNamespaceTests(URLTestCaseBase):

  226.     """

  227.     Tests if the translations are still working within namespaces.

  228.     """

  229. 

  230.     def test_account_register(self):

  231.         with translation.override("en"):

  232.             self.assertEqual(reverse("account:register"), "/en/account/register/")

  233.             self.assertEqual(

  234.                 reverse("account:register-as-path"), "/en/account/register-as-path/"

  235.             )

  236. 

  237.         with translation.override("nl"):

  238.             self.assertEqual(reverse("account:register"), "/nl/profiel/registreren/")

  239.             self.assertEqual(

  240.                 reverse("account:register-as-path"), "/nl/profiel/registreren-als-pad/"

  241.             )

  242. 

  243. 

  244. class URLRedirectTests(URLTestCaseBase):

  245.     """

  246.     Tests if the user gets redirected to the right URL when there is no

  247.     language-prefix in the request URL.

  248.     """

  249. 

  250.     def test_no_prefix_response(self):

  251.         response = self.client.get("/not-prefixed/")

  252.         self.assertEqual(response.status_code, 200)

  253. 

  254.     def test_en_redirect(self):

  255.         response = self.client.get("/account/register/", HTTP_ACCEPT_LANGUAGE="en")

  256.         self.assertRedirects(response, "/en/account/register/")

  257. 

  258.         response = self.client.get(response.headers["location"])

  259.         self.assertEqual(response.status_code, 200)

  260. 

  261.     def test_en_redirect_wrong_url(self):

  262.         response = self.client.get("/profiel/registreren/", HTTP_ACCEPT_LANGUAGE="en")

  263.         self.assertEqual(response.status_code, 404)

  264. 

  265.     def test_nl_redirect(self):

  266.         response = self.client.get("/profiel/registreren/", HTTP_ACCEPT_LANGUAGE="nl")

  267.         self.assertRedirects(response, "/nl/profiel/registreren/")

  268. 

  269.         response = self.client.get(response.headers["location"])

  270.         self.assertEqual(response.status_code, 200)

  271. 

  272.     def test_nl_redirect_wrong_url(self):

  273.         response = self.client.get("/account/register/", HTTP_ACCEPT_LANGUAGE="nl")

  274.         self.assertEqual(response.status_code, 404)

  275. 

  276.     def test_pt_br_redirect(self):

  277.         response = self.client.get("/conta/registre-se/", HTTP_ACCEPT_LANGUAGE="pt-br")

  278.         self.assertRedirects(response, "/pt-br/conta/registre-se/")

  279. 

  280.         response = self.client.get(response.headers["location"])

  281.         self.assertEqual(response.status_code, 200)

  282. 

  283.     def test_pl_pl_redirect(self):

  284.         # language from outside of the supported LANGUAGES list

  285.         response = self.client.get("/account/register/", HTTP_ACCEPT_LANGUAGE="pl-pl")

  286.         self.assertRedirects(response, "/en/account/register/")

  287. 

  288.         response = self.client.get(response.headers["location"])

  289.         self.assertEqual(response.status_code, 200)

  290. 

  291.     @override_settings(

  292.         MIDDLEWARE=[

  293.             "i18n.patterns.tests.PermanentRedirectLocaleMiddleWare",

  294.             "django.middleware.common.CommonMiddleware",

  295.         ],

  296.     )

  297.     def test_custom_redirect_class(self):

  298.         response = self.client.get("/account/register/", HTTP_ACCEPT_LANGUAGE="en")

  299.         self.assertRedirects(response, "/en/account/register/", 301)

  300. 

  301. 

  302. class URLVaryAcceptLanguageTests(URLTestCaseBase):

  303.     """

  304.     'Accept-Language' is not added to the Vary header when using prefixed URLs.

  305.     """

  306. 

  307.     def test_no_prefix_response(self):

  308.         response = self.client.get("/not-prefixed/")

  309.         self.assertEqual(response.status_code, 200)

  310.         self.assertEqual(response.get("Vary"), "Accept-Language")

  311. 

  312.     def test_en_redirect(self):

  313.         """

  314.         The redirect to a prefixed URL depends on 'Accept-Language' and

  315.         'Cookie', but once prefixed no header is set.

  316.         """

  317.         response = self.client.get("/account/register/", HTTP_ACCEPT_LANGUAGE="en")

  318.         self.assertRedirects(response, "/en/account/register/")

  319.         self.assertEqual(response.get("Vary"), "Accept-Language, Cookie")

  320. 

  321.         response = self.client.get(response.headers["location"])

  322.         self.assertEqual(response.status_code, 200)

  323.         self.assertFalse(response.get("Vary"))

  324. 

  325. 

  326. class URLRedirectWithoutTrailingSlashTests(URLTestCaseBase):

  327.     """

  328.     Tests the redirect when the requested URL doesn't end with a slash

  329.     (`settings.APPEND_SLASH=True`).

  330.     """

  331. 

  332.     def test_not_prefixed_redirect(self):

  333.         response = self.client.get("/not-prefixed", HTTP_ACCEPT_LANGUAGE="en")

  334.         self.assertRedirects(response, "/not-prefixed/", 301)

  335. 

  336.     def test_en_redirect(self):

  337.         response = self.client.get(

  338.             "/account/register", HTTP_ACCEPT_LANGUAGE="en", follow=True

  339.         )

  340.         # We only want one redirect, bypassing CommonMiddleware

  341.         self.assertEqual(response.redirect_chain, [("/en/account/register/", 302)])

  342.         self.assertRedirects(response, "/en/account/register/", 302)

  343. 

  344.         response = self.client.get(

  345.             "/prefixed.xml", HTTP_ACCEPT_LANGUAGE="en", follow=True

  346.         )

  347.         self.assertRedirects(response, "/en/prefixed.xml", 302)

  348. 

  349. 

  350. class URLRedirectWithoutTrailingSlashSettingTests(URLTestCaseBase):

  351.     """

  352.     Tests the redirect when the requested URL doesn't end with a slash

  353.     (`settings.APPEND_SLASH=False`).

  354.     """

  355. 

  356.     @override_settings(APPEND_SLASH=False)

  357.     def test_not_prefixed_redirect(self):

  358.         response = self.client.get("/not-prefixed", HTTP_ACCEPT_LANGUAGE="en")

  359.         self.assertEqual(response.status_code, 404)

  360. 

  361.     @override_settings(APPEND_SLASH=False)

  362.     def test_en_redirect(self):

  363.         response = self.client.get(

  364.             "/account/register-without-slash", HTTP_ACCEPT_LANGUAGE="en"

  365.         )

  366.         self.assertRedirects(response, "/en/account/register-without-slash", 302)

  367. 

  368.         response = self.client.get(response.headers["location"])

  369.         self.assertEqual(response.status_code, 200)

  370. 

  371. 

  372. class URLResponseTests(URLTestCaseBase):

  373.     """Tests if the response has the correct language code."""

  374. 

  375.     def test_not_prefixed_with_prefix(self):

  376.         response = self.client.get("/en/not-prefixed/")

  377.         self.assertEqual(response.status_code, 404)

  378. 

  379.     def test_en_url(self):

  380.         response = self.client.get("/en/account/register/")

  381.         self.assertEqual(response.status_code, 200)

  382.         self.assertEqual(response.headers["content-language"], "en")

  383.         self.assertEqual(response.context["LANGUAGE_CODE"], "en")

  384. 

  385.     def test_nl_url(self):

  386.         response = self.client.get("/nl/profiel/registreren/")

  387.         self.assertEqual(response.status_code, 200)

  388.         self.assertEqual(response.headers["content-language"], "nl")

  389.         self.assertEqual(response.context["LANGUAGE_CODE"], "nl")

  390. 

  391.     def test_wrong_en_prefix(self):

  392.         response = self.client.get("/en/profiel/registreren/")

  393.         self.assertEqual(response.status_code, 404)

  394. 

  395.     def test_wrong_nl_prefix(self):

  396.         response = self.client.get("/nl/account/register/")

  397.         self.assertEqual(response.status_code, 404)

  398. 

  399.     def test_pt_br_url(self):

  400.         response = self.client.get("/pt-br/conta/registre-se/")

  401.         self.assertEqual(response.status_code, 200)

  402.         self.assertEqual(response.headers["content-language"], "pt-br")

  403.         self.assertEqual(response.context["LANGUAGE_CODE"], "pt-br")

  404. 

  405.     def test_en_path(self):

  406.         response = self.client.get("/en/account/register-as-path/")

  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_path(self):

  412.         response = self.client.get("/nl/profiel/registreren-als-pad/")

  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. 

  418. class URLRedirectWithScriptAliasTests(URLTestCaseBase):

  419.     """

  420.     #21579 - LocaleMiddleware should respect the script prefix.

  421.     """

  422. 

  423.     def test_language_prefix_with_script_prefix(self):

  424.         prefix = "/script_prefix"

  425.         with override_script_prefix(prefix):

  426.             response = self.client.get(

  427.                 "/prefixed/", HTTP_ACCEPT_LANGUAGE="en", SCRIPT_NAME=prefix

  428.             )

  429.             self.assertRedirects(

  430.                 response, "%s/en/prefixed/" % prefix, target_status_code=404

  431.             )

  432. 

  433. 

  434. class URLTagTests(URLTestCaseBase):

  435.     """

  436.     Test if the language tag works.

  437.     """

  438. 

  439.     def test_strings_only(self):

  440.         t = Template(

  441.             """{% load i18n %}

  442.             {% language 'nl' %}{% url 'no-prefix-translated' %}{% endlanguage %}

  443.             {% language 'pt-br' %}{% url 'no-prefix-translated' %}{% endlanguage %}"""

  444.         )

  445.         self.assertEqual(

  446.             t.render(Context({})).strip().split(), ["/vertaald/", "/traduzidos/"]

  447.         )

  448. 

  449.     def test_context(self):

  450.         ctx = Context({"lang1": "nl", "lang2": "pt-br"})

  451.         tpl = Template(

  452.             """{% load i18n %}

  453.             {% language lang1 %}{% url 'no-prefix-translated' %}{% endlanguage %}

  454.             {% language lang2 %}{% url 'no-prefix-translated' %}{% endlanguage %}"""

  455.         )

  456.         self.assertEqual(

  457.             tpl.render(ctx).strip().split(), ["/vertaald/", "/traduzidos/"]

  458.         )

  459. 

  460.     def test_args(self):

  461.         tpl = Template(

  462.             """

  463.             {% load i18n %}

  464.             {% language 'nl' %}

  465.             {% url 'no-prefix-translated-slug' 'apo' %}{% endlanguage %}

  466.             {% language 'pt-br' %}

  467.             {% url 'no-prefix-translated-slug' 'apo' %}{% endlanguage %}

  468.             """

  469.         )

  470.         self.assertEqual(

  471.             tpl.render(Context({})).strip().split(),

  472.             ["/vertaald/apo/", "/traduzidos/apo/"],

  473.         )

  474. 

  475.     def test_kwargs(self):

  476.         tpl = Template(

  477.             """

  478.             {% load i18n %}

  479.             {% language 'nl'  %}

  480.             {% url 'no-prefix-translated-slug' slug='apo' %}{% endlanguage %}

  481.             {% language 'pt-br' %}

  482.             {% url 'no-prefix-translated-slug' slug='apo' %}{% endlanguage %}

  483.             """

  484.         )

  485.         self.assertEqual(

  486.             tpl.render(Context({})).strip().split(),

  487.             ["/vertaald/apo/", "/traduzidos/apo/"],

  488.         )
About Sign Up Leave Feedback Contact