1. import os

  2. import sys

  3. import unittest

  4. from types import ModuleType, SimpleNamespace

  5. from unittest import mock

  6. 

  7. from django.conf import (

  8.     ENVIRONMENT_VARIABLE,

  9.     USE_DEPRECATED_PYTZ_DEPRECATED_MSG,

  10.     LazySettings,

  11.     Settings,

  12.     settings,

  13. )

  14. from django.core.exceptions import ImproperlyConfigured

  15. from django.http import HttpRequest

  16. from django.test import (

  17.     SimpleTestCase,

  18.     TestCase,

  19.     TransactionTestCase,

  20.     modify_settings,

  21.     override_settings,

  22.     signals,

  23. )

  24. from django.test.utils import requires_tz_support

  25. from django.urls import clear_script_prefix, set_script_prefix

  26. from django.utils.deprecation import RemovedInDjango50Warning

  27. 

  28. 

  29. @modify_settings(ITEMS={"prepend": ["b"], "append": ["d"], "remove": ["a", "e"]})

  30. @override_settings(

  31.     ITEMS=["a", "c", "e"], ITEMS_OUTER=[1, 2, 3], TEST="override", TEST_OUTER="outer"

  32. )

  33. class FullyDecoratedTranTestCase(TransactionTestCase):

  34.     available_apps = []

  35. 

  36.     def test_override(self):

  37.         self.assertEqual(settings.ITEMS, ["b", "c", "d"])

  38.         self.assertEqual(settings.ITEMS_OUTER, [1, 2, 3])

  39.         self.assertEqual(settings.TEST, "override")

  40.         self.assertEqual(settings.TEST_OUTER, "outer")

  41. 

  42.     @modify_settings(

  43.         ITEMS={

  44.             "append": ["e", "f"],

  45.             "prepend": ["a"],

  46.             "remove": ["d", "c"],

  47.         }

  48.     )

  49.     def test_method_list_override(self):

  50.         self.assertEqual(settings.ITEMS, ["a", "b", "e", "f"])

  51.         self.assertEqual(settings.ITEMS_OUTER, [1, 2, 3])

  52. 

  53.     @modify_settings(

  54.         ITEMS={

  55.             "append": ["b"],

  56.             "prepend": ["d"],

  57.             "remove": ["a", "c", "e"],

  58.         }

  59.     )

  60.     def test_method_list_override_no_ops(self):

  61.         self.assertEqual(settings.ITEMS, ["b", "d"])

  62. 

  63.     @modify_settings(

  64.         ITEMS={

  65.             "append": "e",

  66.             "prepend": "a",

  67.             "remove": "c",

  68.         }

  69.     )

  70.     def test_method_list_override_strings(self):

  71.         self.assertEqual(settings.ITEMS, ["a", "b", "d", "e"])

  72. 

  73.     @modify_settings(ITEMS={"remove": ["b", "d"]})

  74.     @modify_settings(ITEMS={"append": ["b"], "prepend": ["d"]})

  75.     def test_method_list_override_nested_order(self):

  76.         self.assertEqual(settings.ITEMS, ["d", "c", "b"])

  77. 

  78.     @override_settings(TEST="override2")

  79.     def test_method_override(self):

  80.         self.assertEqual(settings.TEST, "override2")

  81.         self.assertEqual(settings.TEST_OUTER, "outer")

  82. 

  83.     def test_decorated_testcase_name(self):

  84.         self.assertEqual(

  85.             FullyDecoratedTranTestCase.__name__, "FullyDecoratedTranTestCase"

  86.         )

  87. 

  88.     def test_decorated_testcase_module(self):

  89.         self.assertEqual(FullyDecoratedTranTestCase.__module__, __name__)

  90. 

  91. 

  92. @modify_settings(ITEMS={"prepend": ["b"], "append": ["d"], "remove": ["a", "e"]})

  93. @override_settings(ITEMS=["a", "c", "e"], TEST="override")

  94. class FullyDecoratedTestCase(TestCase):

  95.     def test_override(self):

  96.         self.assertEqual(settings.ITEMS, ["b", "c", "d"])

  97.         self.assertEqual(settings.TEST, "override")

  98. 

  99.     @modify_settings(

  100.         ITEMS={

  101.             "append": "e",

  102.             "prepend": "a",

  103.             "remove": "c",

  104.         }

  105.     )

  106.     @override_settings(TEST="override2")

  107.     def test_method_override(self):

  108.         self.assertEqual(settings.ITEMS, ["a", "b", "d", "e"])

  109.         self.assertEqual(settings.TEST, "override2")

  110. 

  111. 

  112. class ClassDecoratedTestCaseSuper(TestCase):

  113.     """

  114.     Dummy class for testing max recursion error in child class call to

  115.     super().  Refs #17011.

  116.     """

  117. 

  118.     def test_max_recursion_error(self):

  119.         pass

  120. 

  121. 

  122. @override_settings(TEST="override")

  123. class ClassDecoratedTestCase(ClassDecoratedTestCaseSuper):

  124.     @classmethod

  125.     def setUpClass(cls):

  126.         super().setUpClass()

  127.         cls.foo = getattr(settings, "TEST", "BUG")

  128. 

  129.     def test_override(self):

  130.         self.assertEqual(settings.TEST, "override")

  131. 

  132.     def test_setupclass_override(self):

  133.         """Settings are overridden within setUpClass (#21281)."""

  134.         self.assertEqual(self.foo, "override")

  135. 

  136.     @override_settings(TEST="override2")

  137.     def test_method_override(self):

  138.         self.assertEqual(settings.TEST, "override2")

  139. 

  140.     def test_max_recursion_error(self):

  141.         """

  142.         Overriding a method on a super class and then calling that method on

  143.         the super class should not trigger infinite recursion. See #17011.

  144.         """

  145.         super().test_max_recursion_error()

  146. 

  147. 

  148. @modify_settings(ITEMS={"append": "mother"})

  149. @override_settings(ITEMS=["father"], TEST="override-parent")

  150. class ParentDecoratedTestCase(TestCase):

  151.     pass

  152. 

  153. 

  154. @modify_settings(ITEMS={"append": ["child"]})

  155. @override_settings(TEST="override-child")

  156. class ChildDecoratedTestCase(ParentDecoratedTestCase):

  157.     def test_override_settings_inheritance(self):

  158.         self.assertEqual(settings.ITEMS, ["father", "mother", "child"])

  159.         self.assertEqual(settings.TEST, "override-child")

  160. 

  161. 

  162. class SettingsTests(SimpleTestCase):

  163.     def setUp(self):

  164.         self.testvalue = None

  165.         signals.setting_changed.connect(self.signal_callback)

  166. 

  167.     def tearDown(self):

  168.         signals.setting_changed.disconnect(self.signal_callback)

  169. 

  170.     def signal_callback(self, sender, setting, value, **kwargs):

  171.         if setting == "TEST":

  172.             self.testvalue = value

  173. 

  174.     def test_override(self):

  175.         settings.TEST = "test"

  176.         self.assertEqual("test", settings.TEST)

  177.         with self.settings(TEST="override"):

  178.             self.assertEqual("override", settings.TEST)

  179.         self.assertEqual("test", settings.TEST)

  180.         del settings.TEST

  181. 

  182.     def test_override_change(self):

  183.         settings.TEST = "test"

  184.         self.assertEqual("test", settings.TEST)

  185.         with self.settings(TEST="override"):

  186.             self.assertEqual("override", settings.TEST)

  187.             settings.TEST = "test2"

  188.         self.assertEqual("test", settings.TEST)

  189.         del settings.TEST

  190. 

  191.     def test_override_doesnt_leak(self):

  192.         with self.assertRaises(AttributeError):

  193.             getattr(settings, "TEST")

  194.         with self.settings(TEST="override"):

  195.             self.assertEqual("override", settings.TEST)

  196.             settings.TEST = "test"

  197.         with self.assertRaises(AttributeError):

  198.             getattr(settings, "TEST")

  199. 

  200.     @override_settings(TEST="override")

  201.     def test_decorator(self):

  202.         self.assertEqual("override", settings.TEST)

  203. 

  204.     def test_context_manager(self):

  205.         with self.assertRaises(AttributeError):

  206.             getattr(settings, "TEST")

  207.         override = override_settings(TEST="override")

  208.         with self.assertRaises(AttributeError):

  209.             getattr(settings, "TEST")

  210.         override.enable()

  211.         self.assertEqual("override", settings.TEST)

  212.         override.disable()

  213.         with self.assertRaises(AttributeError):

  214.             getattr(settings, "TEST")

  215. 

  216.     def test_class_decorator(self):

  217.         # SimpleTestCase can be decorated by override_settings, but not ut.TestCase

  218.         class SimpleTestCaseSubclass(SimpleTestCase):

  219.             pass

  220. 

  221.         class UnittestTestCaseSubclass(unittest.TestCase):

  222.             pass

  223. 

  224.         decorated = override_settings(TEST="override")(SimpleTestCaseSubclass)

  225.         self.assertIsInstance(decorated, type)

  226.         self.assertTrue(issubclass(decorated, SimpleTestCase))

  227. 

  228.         with self.assertRaisesMessage(

  229.             Exception, "Only subclasses of Django SimpleTestCase"

  230.         ):

  231.             decorated = override_settings(TEST="override")(UnittestTestCaseSubclass)

  232. 

  233.     def test_signal_callback_context_manager(self):

  234.         with self.assertRaises(AttributeError):

  235.             getattr(settings, "TEST")

  236.         with self.settings(TEST="override"):

  237.             self.assertEqual(self.testvalue, "override")

  238.         self.assertIsNone(self.testvalue)

  239. 

  240.     @override_settings(TEST="override")

  241.     def test_signal_callback_decorator(self):

  242.         self.assertEqual(self.testvalue, "override")

  243. 

  244.     #

  245.     # Regression tests for #10130: deleting settings.

  246.     #

  247. 

  248.     def test_settings_delete(self):

  249.         settings.TEST = "test"

  250.         self.assertEqual("test", settings.TEST)

  251.         del settings.TEST

  252.         msg = "'Settings' object has no attribute 'TEST'"

  253.         with self.assertRaisesMessage(AttributeError, msg):

  254.             getattr(settings, "TEST")

  255. 

  256.     def test_settings_delete_wrapped(self):

  257.         with self.assertRaisesMessage(TypeError, "can't delete _wrapped."):

  258.             delattr(settings, "_wrapped")

  259. 

  260.     def test_override_settings_delete(self):

  261.         """

  262.         Allow deletion of a setting in an overridden settings set (#18824)

  263.         """

  264.         previous_i18n = settings.USE_I18N

  265.         previous_tz = settings.USE_TZ

  266.         with self.settings(USE_I18N=False):

  267.             del settings.USE_I18N

  268.             with self.assertRaises(AttributeError):

  269.                 getattr(settings, "USE_I18N")

  270.             # Should also work for a non-overridden setting

  271.             del settings.USE_TZ

  272.             with self.assertRaises(AttributeError):

  273.                 getattr(settings, "USE_TZ")

  274.             self.assertNotIn("USE_I18N", dir(settings))

  275.             self.assertNotIn("USE_TZ", dir(settings))

  276.         self.assertEqual(settings.USE_I18N, previous_i18n)

  277.         self.assertEqual(settings.USE_TZ, previous_tz)

  278. 

  279.     def test_override_settings_nested(self):

  280.         """

  281.         override_settings uses the actual _wrapped attribute at

  282.         runtime, not when it was instantiated.

  283.         """

  284. 

  285.         with self.assertRaises(AttributeError):

  286.             getattr(settings, "TEST")

  287.         with self.assertRaises(AttributeError):

  288.             getattr(settings, "TEST2")

  289. 

  290.         inner = override_settings(TEST2="override")

  291.         with override_settings(TEST="override"):

  292.             self.assertEqual("override", settings.TEST)

  293.             with inner:

  294.                 self.assertEqual("override", settings.TEST)

  295.                 self.assertEqual("override", settings.TEST2)

  296.             # inner's __exit__ should have restored the settings of the outer

  297.             # context manager, not those when the class was instantiated

  298.             self.assertEqual("override", settings.TEST)

  299.             with self.assertRaises(AttributeError):

  300.                 getattr(settings, "TEST2")

  301. 

  302.         with self.assertRaises(AttributeError):

  303.             getattr(settings, "TEST")

  304.         with self.assertRaises(AttributeError):

  305.             getattr(settings, "TEST2")

  306. 

  307.     @override_settings(SECRET_KEY="")

  308.     def test_no_secret_key(self):

  309.         msg = "The SECRET_KEY setting must not be empty."

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

  311.             settings.SECRET_KEY

  312. 

  313.     def test_no_settings_module(self):

  314.         msg = (

  315.             "Requested setting%s, but settings are not configured. You "

  316.             "must either define the environment variable DJANGO_SETTINGS_MODULE "

  317.             "or call settings.configure() before accessing settings."

  318.         )

  319.         orig_settings = os.environ[ENVIRONMENT_VARIABLE]

  320.         os.environ[ENVIRONMENT_VARIABLE] = ""

  321.         try:

  322.             with self.assertRaisesMessage(ImproperlyConfigured, msg % "s"):

  323.                 settings._setup()

  324.             with self.assertRaisesMessage(ImproperlyConfigured, msg % " TEST"):

  325.                 settings._setup("TEST")

  326.         finally:

  327.             os.environ[ENVIRONMENT_VARIABLE] = orig_settings

  328. 

  329.     def test_already_configured(self):

  330.         with self.assertRaisesMessage(RuntimeError, "Settings already configured."):

  331.             settings.configure()

  332. 

  333.     def test_nonupper_settings_prohibited_in_configure(self):

  334.         s = LazySettings()

  335.         with self.assertRaisesMessage(TypeError, "Setting 'foo' must be uppercase."):

  336.             s.configure(foo="bar")

  337. 

  338.     def test_nonupper_settings_ignored_in_default_settings(self):

  339.         s = LazySettings()

  340.         s.configure(SimpleNamespace(foo="bar"))

  341.         with self.assertRaises(AttributeError):

  342.             getattr(s, "foo")

  343. 

  344.     @requires_tz_support

  345.     @mock.patch("django.conf.global_settings.TIME_ZONE", "test")

  346.     def test_incorrect_timezone(self):

  347.         with self.assertRaisesMessage(ValueError, "Incorrect timezone setting: test"):

  348.             settings._setup()

  349. 

  350.     def test_use_tz_false_deprecation(self):

  351.         settings_module = ModuleType("fake_settings_module")

  352.         settings_module.SECRET_KEY = "foo"

  353.         sys.modules["fake_settings_module"] = settings_module

  354.         msg = (

  355.             "The default value of USE_TZ will change from False to True in "

  356.             "Django 5.0. Set USE_TZ to False in your project settings if you "

  357.             "want to keep the current default behavior."

  358.         )

  359.         try:

  360.             with self.assertRaisesMessage(RemovedInDjango50Warning, msg):

  361.                 Settings("fake_settings_module")

  362.         finally:

  363.             del sys.modules["fake_settings_module"]

  364. 

  365.     def test_use_deprecated_pytz_deprecation(self):

  366.         settings_module = ModuleType("fake_settings_module")

  367.         settings_module.USE_DEPRECATED_PYTZ = True

  368.         settings_module.USE_TZ = True

  369.         sys.modules["fake_settings_module"] = settings_module

  370.         try:

  371.             with self.assertRaisesMessage(

  372.                 RemovedInDjango50Warning, USE_DEPRECATED_PYTZ_DEPRECATED_MSG

  373.             ):

  374.                 Settings("fake_settings_module")

  375.         finally:

  376.             del sys.modules["fake_settings_module"]

  377. 

  378.         holder = LazySettings()

  379.         with self.assertRaisesMessage(

  380.             RemovedInDjango50Warning, USE_DEPRECATED_PYTZ_DEPRECATED_MSG

  381.         ):

  382.             holder.configure(USE_DEPRECATED_PYTZ=True)

  383. 

  384. 

  385. class TestComplexSettingOverride(SimpleTestCase):

  386.     def setUp(self):

  387.         self.old_warn_override_settings = signals.COMPLEX_OVERRIDE_SETTINGS.copy()

  388.         signals.COMPLEX_OVERRIDE_SETTINGS.add("TEST_WARN")

  389. 

  390.     def tearDown(self):

  391.         signals.COMPLEX_OVERRIDE_SETTINGS = self.old_warn_override_settings

  392.         self.assertNotIn("TEST_WARN", signals.COMPLEX_OVERRIDE_SETTINGS)

  393. 

  394.     def test_complex_override_warning(self):

  395.         """Regression test for #19031"""

  396.         msg = "Overriding setting TEST_WARN can lead to unexpected behavior."

  397.         with self.assertWarnsMessage(UserWarning, msg) as cm:

  398.             with override_settings(TEST_WARN="override"):

  399.                 self.assertEqual(settings.TEST_WARN, "override")

  400.         self.assertEqual(cm.filename, __file__)

  401. 

  402. 

  403. class SecureProxySslHeaderTest(SimpleTestCase):

  404.     @override_settings(SECURE_PROXY_SSL_HEADER=None)

  405.     def test_none(self):

  406.         req = HttpRequest()

  407.         self.assertIs(req.is_secure(), False)

  408. 

  409.     @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))

  410.     def test_set_without_xheader(self):

  411.         req = HttpRequest()

  412.         self.assertIs(req.is_secure(), False)

  413. 

  414.     @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))

  415.     def test_set_with_xheader_wrong(self):

  416.         req = HttpRequest()

  417.         req.META["HTTP_X_FORWARDED_PROTO"] = "wrongvalue"

  418.         self.assertIs(req.is_secure(), False)

  419. 

  420.     @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))

  421.     def test_set_with_xheader_right(self):

  422.         req = HttpRequest()

  423.         req.META["HTTP_X_FORWARDED_PROTO"] = "https"

  424.         self.assertIs(req.is_secure(), True)

  425. 

  426.     @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))

  427.     def test_set_with_xheader_leftmost_right(self):

  428.         req = HttpRequest()

  429.         req.META["HTTP_X_FORWARDED_PROTO"] = "https, http"

  430.         self.assertIs(req.is_secure(), True)

  431.         req.META["HTTP_X_FORWARDED_PROTO"] = "https  , http"

  432.         self.assertIs(req.is_secure(), True)

  433. 

  434.     @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))

  435.     def test_set_with_xheader_leftmost_not_secure(self):

  436.         req = HttpRequest()

  437.         req.META["HTTP_X_FORWARDED_PROTO"] = "http, https"

  438.         self.assertIs(req.is_secure(), False)

  439. 

  440.     @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))

  441.     def test_set_with_xheader_multiple_not_secure(self):

  442.         req = HttpRequest()

  443.         req.META["HTTP_X_FORWARDED_PROTO"] = "http ,wrongvalue,http,http"

  444.         self.assertIs(req.is_secure(), False)

  445. 

  446.     @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))

  447.     def test_xheader_preferred_to_underlying_request(self):

  448.         class ProxyRequest(HttpRequest):

  449.             def _get_scheme(self):

  450.                 """Proxy always connecting via HTTPS"""

  451.                 return "https"

  452. 

  453.         # Client connects via HTTP.

  454.         req = ProxyRequest()

  455.         req.META["HTTP_X_FORWARDED_PROTO"] = "http"

  456.         self.assertIs(req.is_secure(), False)

  457. 

  458. 

  459. class IsOverriddenTest(SimpleTestCase):

  460.     def test_configure(self):

  461.         s = LazySettings()

  462.         s.configure(SECRET_KEY="foo")

  463. 

  464.         self.assertTrue(s.is_overridden("SECRET_KEY"))

  465. 

  466.     def test_module(self):

  467.         settings_module = ModuleType("fake_settings_module")

  468.         settings_module.SECRET_KEY = "foo"

  469.         settings_module.USE_TZ = False

  470.         sys.modules["fake_settings_module"] = settings_module

  471.         try:

  472.             s = Settings("fake_settings_module")

  473. 

  474.             self.assertTrue(s.is_overridden("SECRET_KEY"))

  475.             self.assertFalse(s.is_overridden("ALLOWED_HOSTS"))

  476.         finally:

  477.             del sys.modules["fake_settings_module"]

  478. 

  479.     def test_override(self):

  480.         self.assertFalse(settings.is_overridden("ALLOWED_HOSTS"))

  481.         with override_settings(ALLOWED_HOSTS=[]):

  482.             self.assertTrue(settings.is_overridden("ALLOWED_HOSTS"))

  483. 

  484.     def test_unevaluated_lazysettings_repr(self):

  485.         lazy_settings = LazySettings()

  486.         expected = "<LazySettings [Unevaluated]>"

  487.         self.assertEqual(repr(lazy_settings), expected)

  488. 

  489.     def test_evaluated_lazysettings_repr(self):

  490.         lazy_settings = LazySettings()

  491.         module = os.environ.get(ENVIRONMENT_VARIABLE)

  492.         expected = '<LazySettings "%s">' % module

  493.         # Force evaluation of the lazy object.

  494.         lazy_settings.APPEND_SLASH

  495.         self.assertEqual(repr(lazy_settings), expected)

  496. 

  497.     def test_usersettingsholder_repr(self):

  498.         lazy_settings = LazySettings()

  499.         lazy_settings.configure(APPEND_SLASH=False)

  500.         expected = "<UserSettingsHolder>"

  501.         self.assertEqual(repr(lazy_settings._wrapped), expected)

  502. 

  503.     def test_settings_repr(self):

  504.         module = os.environ.get(ENVIRONMENT_VARIABLE)

  505.         lazy_settings = Settings(module)

  506.         expected = '<Settings "%s">' % module

  507.         self.assertEqual(repr(lazy_settings), expected)

  508. 

  509. 

  510. class TestListSettings(SimpleTestCase):

  511.     """

  512.     Make sure settings that should be lists or tuples throw

  513.     ImproperlyConfigured if they are set to a string instead of a list or tuple.

  514.     """

  515. 

  516.     list_or_tuple_settings = (

  517.         "ALLOWED_HOSTS",

  518.         "INSTALLED_APPS",

  519.         "TEMPLATE_DIRS",

  520.         "LOCALE_PATHS",

  521.         "SECRET_KEY_FALLBACKS",

  522.     )

  523. 

  524.     def test_tuple_settings(self):

  525.         settings_module = ModuleType("fake_settings_module")

  526.         settings_module.SECRET_KEY = "foo"

  527.         msg = "The %s setting must be a list or a tuple."

  528.         for setting in self.list_or_tuple_settings:

  529.             setattr(settings_module, setting, ("non_list_or_tuple_value"))

  530.             sys.modules["fake_settings_module"] = settings_module

  531.             try:

  532.                 with self.assertRaisesMessage(ImproperlyConfigured, msg % setting):

  533.                     Settings("fake_settings_module")

  534.             finally:

  535.                 del sys.modules["fake_settings_module"]

  536.                 delattr(settings_module, setting)

  537. 

  538. 

  539. class SettingChangeEnterException(Exception):

  540.     pass

  541. 

  542. 

  543. class SettingChangeExitException(Exception):

  544.     pass

  545. 

  546. 

  547. class OverrideSettingsIsolationOnExceptionTests(SimpleTestCase):

  548.     """

  549.     The override_settings context manager restore settings if one of the

  550.     receivers of "setting_changed" signal fails. Check the three cases of

  551.     receiver failure detailed in receiver(). In each case, ALL receivers are

  552.     called when exiting the context manager.

  553.     """

  554. 

  555.     def setUp(self):

  556.         signals.setting_changed.connect(self.receiver)

  557.         self.addCleanup(signals.setting_changed.disconnect, self.receiver)

  558.         # Create a spy that's connected to the `setting_changed` signal and

  559.         # executed AFTER `self.receiver`.

  560.         self.spy_receiver = mock.Mock()

  561.         signals.setting_changed.connect(self.spy_receiver)

  562.         self.addCleanup(signals.setting_changed.disconnect, self.spy_receiver)

  563. 

  564.     def receiver(self, **kwargs):

  565.         """

  566.         A receiver that fails while certain settings are being changed.

  567.         - SETTING_BOTH raises an error while receiving the signal

  568.           on both entering and exiting the context manager.

  569.         - SETTING_ENTER raises an error only on enter.

  570.         - SETTING_EXIT raises an error only on exit.

  571.         """

  572.         setting = kwargs["setting"]

  573.         enter = kwargs["enter"]

  574.         if setting in ("SETTING_BOTH", "SETTING_ENTER") and enter:

  575.             raise SettingChangeEnterException

  576.         if setting in ("SETTING_BOTH", "SETTING_EXIT") and not enter:

  577.             raise SettingChangeExitException

  578. 

  579.     def check_settings(self):

  580.         """Assert that settings for these tests aren't present."""

  581.         self.assertFalse(hasattr(settings, "SETTING_BOTH"))

  582.         self.assertFalse(hasattr(settings, "SETTING_ENTER"))

  583.         self.assertFalse(hasattr(settings, "SETTING_EXIT"))

  584.         self.assertFalse(hasattr(settings, "SETTING_PASS"))

  585. 

  586.     def check_spy_receiver_exit_calls(self, call_count):

  587.         """

  588.         Assert that `self.spy_receiver` was called exactly `call_count` times

  589.         with the ``enter=False`` keyword argument.

  590.         """

  591.         kwargs_with_exit = [

  592.             kwargs

  593.             for args, kwargs in self.spy_receiver.call_args_list

  594.             if ("enter", False) in kwargs.items()

  595.         ]

  596.         self.assertEqual(len(kwargs_with_exit), call_count)

  597. 

  598.     def test_override_settings_both(self):

  599.         """Receiver fails on both enter and exit."""

  600.         with self.assertRaises(SettingChangeEnterException):

  601.             with override_settings(SETTING_PASS="BOTH", SETTING_BOTH="BOTH"):

  602.                 pass

  603. 

  604.         self.check_settings()

  605.         # Two settings were touched, so expect two calls of `spy_receiver`.

  606.         self.check_spy_receiver_exit_calls(call_count=2)

  607. 

  608.     def test_override_settings_enter(self):

  609.         """Receiver fails on enter only."""

  610.         with self.assertRaises(SettingChangeEnterException):

  611.             with override_settings(SETTING_PASS="ENTER", SETTING_ENTER="ENTER"):

  612.                 pass

  613. 

  614.         self.check_settings()

  615.         # Two settings were touched, so expect two calls of `spy_receiver`.

  616.         self.check_spy_receiver_exit_calls(call_count=2)

  617. 

  618.     def test_override_settings_exit(self):

  619.         """Receiver fails on exit only."""

  620.         with self.assertRaises(SettingChangeExitException):

  621.             with override_settings(SETTING_PASS="EXIT", SETTING_EXIT="EXIT"):

  622.                 pass

  623. 

  624.         self.check_settings()

  625.         # Two settings were touched, so expect two calls of `spy_receiver`.

  626.         self.check_spy_receiver_exit_calls(call_count=2)

  627. 

  628.     def test_override_settings_reusable_on_enter(self):

  629.         """

  630.         Error is raised correctly when reusing the same override_settings

  631.         instance.

  632.         """

  633. 

  634.         @override_settings(SETTING_ENTER="ENTER")

  635.         def decorated_function():

  636.             pass

  637. 

  638.         with self.assertRaises(SettingChangeEnterException):

  639.             decorated_function()

  640.         signals.setting_changed.disconnect(self.receiver)

  641.         # This call shouldn't raise any errors.

  642.         decorated_function()

  643. 

  644. 

  645. class MediaURLStaticURLPrefixTest(SimpleTestCase):

  646.     def set_script_name(self, val):

  647.         clear_script_prefix()

  648.         if val is not None:

  649.             set_script_prefix(val)

  650. 

  651.     def test_not_prefixed(self):

  652.         # Don't add SCRIPT_NAME prefix to absolute paths, URLs, or None.

  653.         tests = (

  654.             "/path/",

  655.             "http://myhost.com/path/",

  656.             "http://myhost/path/",

  657.             "https://myhost/path/",

  658.             None,

  659.         )

  660.         for setting in ("MEDIA_URL", "STATIC_URL"):

  661.             for path in tests:

  662.                 new_settings = {setting: path}

  663.                 with self.settings(**new_settings):

  664.                     for script_name in ["/somesubpath", "/somesubpath/", "/", "", None]:

  665.                         with self.subTest(script_name=script_name, **new_settings):

  666.                             try:

  667.                                 self.set_script_name(script_name)

  668.                                 self.assertEqual(getattr(settings, setting), path)

  669.                             finally:

  670.                                 clear_script_prefix()

  671. 

  672.     def test_add_script_name_prefix(self):

  673.         tests = (

  674.             # Relative paths.

  675.             ("/somesubpath", "path/", "/somesubpath/path/"),

  676.             ("/somesubpath/", "path/", "/somesubpath/path/"),

  677.             ("/", "path/", "/path/"),

  678.             # Invalid URLs.

  679.             (

  680.                 "/somesubpath/",

  681.                 "htp://myhost.com/path/",

  682.                 "/somesubpath/htp://myhost.com/path/",

  683.             ),

  684.             # Blank settings.

  685.             ("/somesubpath/", "", "/somesubpath/"),

  686.         )

  687.         for setting in ("MEDIA_URL", "STATIC_URL"):

  688.             for script_name, path, expected_path in tests:

  689.                 new_settings = {setting: path}

  690.                 with self.settings(**new_settings):

  691.                     with self.subTest(script_name=script_name, **new_settings):

  692.                         try:

  693.                             self.set_script_name(script_name)

  694.                             self.assertEqual(getattr(settings, setting), expected_path)

  695.                         finally:

  696.                             clear_script_prefix()
About Sign Up Leave Feedback Contact