Debian Codegraph @

tests/settings_tests/tests.py

raw
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 ENVIRONMENT_VARIABLE, LazySettings, Settings, settings
8 from django.core.exceptions import ImproperlyConfigured
9 from django.http import HttpRequest
10 from django.test import (
11 SimpleTestCase,
12 TestCase,
13 TransactionTestCase,
14 modify_settings,
15 override_settings,
16 signals,
17 )
18 from django.test.utils import requires_tz_support
19 from django.urls import clear_script_prefix, set_script_prefix
20
21
22 @modify_settings(ITEMS={"prepend": ["b"], "append": ["d"], "remove": ["a", "e"]})
23 @override_settings(
24 ITEMS=["a", "c", "e"], ITEMS_OUTER=[1, 2, 3], TEST="override", TEST_OUTER="outer"
25 )
26 class FullyDecoratedTranTestCase(TransactionTestCase):
27 available_apps = []
28
29 def test_override(self):
30 self.assertEqual(settings.ITEMS, ["b", "c", "d"])
31 self.assertEqual(settings.ITEMS_OUTER, [1, 2, 3])
32 self.assertEqual(settings.TEST, "override")
33 self.assertEqual(settings.TEST_OUTER, "outer")
34
35 @modify_settings(
36 ITEMS={
37 "append": ["e", "f"],
38 "prepend": ["a"],
39 "remove": ["d", "c"],
40 }
41 )
42 def test_method_list_override(self):
43 self.assertEqual(settings.ITEMS, ["a", "b", "e", "f"])
44 self.assertEqual(settings.ITEMS_OUTER, [1, 2, 3])
45
46 @modify_settings(
47 ITEMS={
48 "append": ["b"],
49 "prepend": ["d"],
50 "remove": ["a", "c", "e"],
51 }
52 )
53 def test_method_list_override_no_ops(self):
54 self.assertEqual(settings.ITEMS, ["b", "d"])
55
56 @modify_settings(
57 ITEMS={
58 "append": "e",
59 "prepend": "a",
60 "remove": "c",
61 }
62 )
63 def test_method_list_override_strings(self):
64 self.assertEqual(settings.ITEMS, ["a", "b", "d", "e"])
65
66 @modify_settings(ITEMS={"remove": ["b", "d"]})
67 @modify_settings(ITEMS={"append": ["b"], "prepend": ["d"]})
68 def test_method_list_override_nested_order(self):
69 self.assertEqual(settings.ITEMS, ["d", "c", "b"])
70
71 @override_settings(TEST="override2")
72 def test_method_override(self):
73 self.assertEqual(settings.TEST, "override2")
74 self.assertEqual(settings.TEST_OUTER, "outer")
75
76 def test_decorated_testcase_name(self):
77 self.assertEqual(
78 FullyDecoratedTranTestCase.__name__, "FullyDecoratedTranTestCase"
79 )
80
81 def test_decorated_testcase_module(self):
82 self.assertEqual(FullyDecoratedTranTestCase.__module__, __name__)
83
84
85 @modify_settings(ITEMS={"prepend": ["b"], "append": ["d"], "remove": ["a", "e"]})
86 @override_settings(ITEMS=["a", "c", "e"], TEST="override")
87 class FullyDecoratedTestCase(TestCase):
88 def test_override(self):
89 self.assertEqual(settings.ITEMS, ["b", "c", "d"])
90 self.assertEqual(settings.TEST, "override")
91
92 @modify_settings(
93 ITEMS={
94 "append": "e",
95 "prepend": "a",
96 "remove": "c",
97 }
98 )
99 @override_settings(TEST="override2")
100 def test_method_override(self):
101 self.assertEqual(settings.ITEMS, ["a", "b", "d", "e"])
102 self.assertEqual(settings.TEST, "override2")
103
104
105 class ClassDecoratedTestCaseSuper(TestCase):
106 """
107 Dummy class for testing max recursion error in child class call to
108 super(). Refs #17011.
109 """
110
111 def test_max_recursion_error(self):
112 pass
113
114
115 @override_settings(TEST="override")
116 class ClassDecoratedTestCase(ClassDecoratedTestCaseSuper):
117 @classmethod
118 def setUpClass(cls):
119 super().setUpClass()
120 cls.foo = getattr(settings, "TEST", "BUG")
121
122 def test_override(self):
123 self.assertEqual(settings.TEST, "override")
124
125 def test_setupclass_override(self):
126 """Settings are overridden within setUpClass (#21281)."""
127 self.assertEqual(self.foo, "override")
128
129 @override_settings(TEST="override2")
130 def test_method_override(self):
131 self.assertEqual(settings.TEST, "override2")
132
133 def test_max_recursion_error(self):
134 """
135 Overriding a method on a super class and then calling that method on
136 the super class should not trigger infinite recursion. See #17011.
137 """
138 super().test_max_recursion_error()
139
140
141 @modify_settings(ITEMS={"append": "mother"})
142 @override_settings(ITEMS=["father"], TEST="override-parent")
143 class ParentDecoratedTestCase(TestCase):
144 pass
145
146
147 @modify_settings(ITEMS={"append": ["child"]})
148 @override_settings(TEST="override-child")
149 class ChildDecoratedTestCase(ParentDecoratedTestCase):
150 def test_override_settings_inheritance(self):
151 self.assertEqual(settings.ITEMS, ["father", "mother", "child"])
152 self.assertEqual(settings.TEST, "override-child")
153
154
155 class SettingsTests(SimpleTestCase):
156 def setUp(self):
157 self.testvalue = None
158 signals.setting_changed.connect(self.signal_callback)
159 self.addCleanup(signals.setting_changed.disconnect, self.signal_callback)
160
161 def signal_callback(self, sender, setting, value, **kwargs):
162 if setting == "TEST":
163 self.testvalue = value
164
165 def test_override(self):
166 settings.TEST = "test"
167 self.assertEqual("test", settings.TEST)
168 with self.settings(TEST="override"):
169 self.assertEqual("override", settings.TEST)
170 self.assertEqual("test", settings.TEST)
171 del settings.TEST
172
173 def test_override_change(self):
174 settings.TEST = "test"
175 self.assertEqual("test", settings.TEST)
176 with self.settings(TEST="override"):
177 self.assertEqual("override", settings.TEST)
178 settings.TEST = "test2"
179 self.assertEqual("test", settings.TEST)
180 del settings.TEST
181
182 def test_override_doesnt_leak(self):
183 with self.assertRaises(AttributeError):
184 getattr(settings, "TEST")
185 with self.settings(TEST="override"):
186 self.assertEqual("override", settings.TEST)
187 settings.TEST = "test"
188 with self.assertRaises(AttributeError):
189 getattr(settings, "TEST")
190
191 @override_settings(TEST="override")
192 def test_decorator(self):
193 self.assertEqual("override", settings.TEST)
194
195 def test_context_manager(self):
196 with self.assertRaises(AttributeError):
197 getattr(settings, "TEST")
198 override = override_settings(TEST="override")
199 with self.assertRaises(AttributeError):
200 getattr(settings, "TEST")
201 override.enable()
202 self.assertEqual("override", settings.TEST)
203 override.disable()
204 with self.assertRaises(AttributeError):
205 getattr(settings, "TEST")
206
207 def test_class_decorator(self):
208 # SimpleTestCase can be decorated by override_settings, but not ut.TestCase
209 class SimpleTestCaseSubclass(SimpleTestCase):
210 pass
211
212 class UnittestTestCaseSubclass(unittest.TestCase):
213 pass
214
215 decorated = override_settings(TEST="override")(SimpleTestCaseSubclass)
216 self.assertIsInstance(decorated, type)
217 self.assertTrue(issubclass(decorated, SimpleTestCase))
218
219 with self.assertRaisesMessage(
220 Exception, "Only subclasses of Django SimpleTestCase"
221 ):
222 decorated = override_settings(TEST="override")(UnittestTestCaseSubclass)
223
224 def test_signal_callback_context_manager(self):
225 with self.assertRaises(AttributeError):
226 getattr(settings, "TEST")
227 with self.settings(TEST="override"):
228 self.assertEqual(self.testvalue, "override")
229 self.assertIsNone(self.testvalue)
230
231 @override_settings(TEST="override")
232 def test_signal_callback_decorator(self):
233 self.assertEqual(self.testvalue, "override")
234
235 #
236 # Regression tests for #10130: deleting settings.
237 #
238
239 def test_settings_delete(self):
240 settings.TEST = "test"
241 self.assertEqual("test", settings.TEST)
242 del settings.TEST
243 msg = "'Settings' object has no attribute 'TEST'"
244 with self.assertRaisesMessage(AttributeError, msg):
245 getattr(settings, "TEST")
246
247 def test_settings_delete_wrapped(self):
248 with self.assertRaisesMessage(TypeError, "can't delete _wrapped."):
249 delattr(settings, "_wrapped")
250
251 def test_override_settings_delete(self):
252 """
253 Allow deletion of a setting in an overridden settings set (#18824)
254 """
255 previous_i18n = settings.USE_I18N
256 previous_tz = settings.USE_TZ
257 with self.settings(USE_I18N=False):
258 del settings.USE_I18N
259 with self.assertRaises(AttributeError):
260 getattr(settings, "USE_I18N")
261 # Should also work for a non-overridden setting
262 del settings.USE_TZ
263 with self.assertRaises(AttributeError):
264 getattr(settings, "USE_TZ")
265 self.assertNotIn("USE_I18N", dir(settings))
266 self.assertNotIn("USE_TZ", dir(settings))
267 self.assertEqual(settings.USE_I18N, previous_i18n)
268 self.assertEqual(settings.USE_TZ, previous_tz)
269
270 def test_override_settings_nested(self):
271 """
272 override_settings uses the actual _wrapped attribute at
273 runtime, not when it was instantiated.
274 """
275
276 with self.assertRaises(AttributeError):
277 getattr(settings, "TEST")
278 with self.assertRaises(AttributeError):
279 getattr(settings, "TEST2")
280
281 inner = override_settings(TEST2="override")
282 with override_settings(TEST="override"):
283 self.assertEqual("override", settings.TEST)
284 with inner:
285 self.assertEqual("override", settings.TEST)
286 self.assertEqual("override", settings.TEST2)
287 # inner's __exit__ should have restored the settings of the outer
288 # context manager, not those when the class was instantiated
289 self.assertEqual("override", settings.TEST)
290 with self.assertRaises(AttributeError):
291 getattr(settings, "TEST2")
292
293 with self.assertRaises(AttributeError):
294 getattr(settings, "TEST")
295 with self.assertRaises(AttributeError):
296 getattr(settings, "TEST2")
297
298 @override_settings(SECRET_KEY="")
299 def test_no_secret_key(self):
300 msg = "The SECRET_KEY setting must not be empty."
301 with self.assertRaisesMessage(ImproperlyConfigured, msg):
302 settings.SECRET_KEY
303
304 def test_no_settings_module(self):
305 msg = (
306 "Requested setting%s, but settings are not configured. You "
307 "must either define the environment variable DJANGO_SETTINGS_MODULE "
308 "or call settings.configure() before accessing settings."
309 )
310 orig_settings = os.environ[ENVIRONMENT_VARIABLE]
311 os.environ[ENVIRONMENT_VARIABLE] = ""
312 try:
313 with self.assertRaisesMessage(ImproperlyConfigured, msg % "s"):
314 settings._setup()
315 with self.assertRaisesMessage(ImproperlyConfigured, msg % " TEST"):
316 settings._setup("TEST")
317 finally:
318 os.environ[ENVIRONMENT_VARIABLE] = orig_settings
319
320 def test_already_configured(self):
321 with self.assertRaisesMessage(RuntimeError, "Settings already configured."):
322 settings.configure()
323
324 def test_nonupper_settings_prohibited_in_configure(self):
325 s = LazySettings()
326 with self.assertRaisesMessage(TypeError, "Setting 'foo' must be uppercase."):
327 s.configure(foo="bar")
328
329 def test_nonupper_settings_ignored_in_default_settings(self):
330 s = LazySettings()
331 s.configure(SimpleNamespace(foo="bar"))
332 with self.assertRaises(AttributeError):
333 getattr(s, "foo")
334
335 @requires_tz_support
336 @mock.patch("django.conf.global_settings.TIME_ZONE", "test")
337 def test_incorrect_timezone(self):
338 with self.assertRaisesMessage(ValueError, "Incorrect timezone setting: test"):
339 settings._setup()
340
341
342 class TestComplexSettingOverride(SimpleTestCase):
343 def setUp(self):
344 self.old_warn_override_settings = signals.COMPLEX_OVERRIDE_SETTINGS.copy()
345 signals.COMPLEX_OVERRIDE_SETTINGS.add("TEST_WARN")
346
347 def tearDown(self):
348 signals.COMPLEX_OVERRIDE_SETTINGS = self.old_warn_override_settings
349 self.assertNotIn("TEST_WARN", signals.COMPLEX_OVERRIDE_SETTINGS)
350
351 def test_complex_override_warning(self):
352 """Regression test for #19031"""
353 msg = "Overriding setting TEST_WARN can lead to unexpected behavior."
354 with self.assertWarnsMessage(UserWarning, msg) as cm:
355 with override_settings(TEST_WARN="override"):
356 self.assertEqual(settings.TEST_WARN, "override")
357 self.assertEqual(cm.filename, __file__)
358
359
360 class SecureProxySslHeaderTest(SimpleTestCase):
361 @override_settings(SECURE_PROXY_SSL_HEADER=None)
362 def test_none(self):
363 req = HttpRequest()
364 self.assertIs(req.is_secure(), False)
365
366 @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))
367 def test_set_without_xheader(self):
368 req = HttpRequest()
369 self.assertIs(req.is_secure(), False)
370
371 @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))
372 def test_set_with_xheader_wrong(self):
373 req = HttpRequest()
374 req.META["HTTP_X_FORWARDED_PROTO"] = "wrongvalue"
375 self.assertIs(req.is_secure(), False)
376
377 @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))
378 def test_set_with_xheader_right(self):
379 req = HttpRequest()
380 req.META["HTTP_X_FORWARDED_PROTO"] = "https"
381 self.assertIs(req.is_secure(), True)
382
383 @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))
384 def test_set_with_xheader_leftmost_right(self):
385 req = HttpRequest()
386 req.META["HTTP_X_FORWARDED_PROTO"] = "https, http"
387 self.assertIs(req.is_secure(), True)
388 req.META["HTTP_X_FORWARDED_PROTO"] = "https , http"
389 self.assertIs(req.is_secure(), True)
390
391 @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))
392 def test_set_with_xheader_leftmost_not_secure(self):
393 req = HttpRequest()
394 req.META["HTTP_X_FORWARDED_PROTO"] = "http, https"
395 self.assertIs(req.is_secure(), False)
396
397 @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))
398 def test_set_with_xheader_multiple_not_secure(self):
399 req = HttpRequest()
400 req.META["HTTP_X_FORWARDED_PROTO"] = "http ,wrongvalue,http,http"
401 self.assertIs(req.is_secure(), False)
402
403 @override_settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_FORWARDED_PROTO", "https"))
404 def test_xheader_preferred_to_underlying_request(self):
405 class ProxyRequest(HttpRequest):
406 def _get_scheme(self):
407 """Proxy always connecting via HTTPS"""
408 return "https"
409
410 # Client connects via HTTP.
411 req = ProxyRequest()
412 req.META["HTTP_X_FORWARDED_PROTO"] = "http"
413 self.assertIs(req.is_secure(), False)
414
415
416 class IsOverriddenTest(SimpleTestCase):
417 def test_configure(self):
418 s = LazySettings()
419 s.configure(SECRET_KEY="foo")
420
421 self.assertTrue(s.is_overridden("SECRET_KEY"))
422
423 def test_module(self):
424 settings_module = ModuleType("fake_settings_module")
425 settings_module.SECRET_KEY = "foo"
426 settings_module.USE_TZ = False
427 sys.modules["fake_settings_module"] = settings_module
428 try:
429 s = Settings("fake_settings_module")
430
431 self.assertTrue(s.is_overridden("SECRET_KEY"))
432 self.assertFalse(s.is_overridden("ALLOWED_HOSTS"))
433 finally:
434 del sys.modules["fake_settings_module"]
435
436 def test_override(self):
437 self.assertFalse(settings.is_overridden("ALLOWED_HOSTS"))
438 with override_settings(ALLOWED_HOSTS=[]):
439 self.assertTrue(settings.is_overridden("ALLOWED_HOSTS"))
440
441 def test_unevaluated_lazysettings_repr(self):
442 lazy_settings = LazySettings()
443 expected = "<LazySettings [Unevaluated]>"
444 self.assertEqual(repr(lazy_settings), expected)
445
446 def test_evaluated_lazysettings_repr(self):
447 lazy_settings = LazySettings()
448 module = os.environ.get(ENVIRONMENT_VARIABLE)
449 expected = '<LazySettings "%s">' % module
450 # Force evaluation of the lazy object.
451 lazy_settings.APPEND_SLASH
452 self.assertEqual(repr(lazy_settings), expected)
453
454 def test_usersettingsholder_repr(self):
455 lazy_settings = LazySettings()
456 lazy_settings.configure(APPEND_SLASH=False)
457 expected = "<UserSettingsHolder>"
458 self.assertEqual(repr(lazy_settings._wrapped), expected)
459
460 def test_settings_repr(self):
461 module = os.environ.get(ENVIRONMENT_VARIABLE)
462 lazy_settings = Settings(module)
463 expected = '<Settings "%s">' % module
464 self.assertEqual(repr(lazy_settings), expected)
465
466
467 class TestListSettings(SimpleTestCase):
468 """
469 Make sure settings that should be lists or tuples throw
470 ImproperlyConfigured if they are set to a string instead of a list or tuple.
471 """
472
473 list_or_tuple_settings = (
474 "ALLOWED_HOSTS",
475 "INSTALLED_APPS",
476 "TEMPLATE_DIRS",
477 "LOCALE_PATHS",
478 "SECRET_KEY_FALLBACKS",
479 )
480
481 def test_tuple_settings(self):
482 settings_module = ModuleType("fake_settings_module")
483 settings_module.SECRET_KEY = "foo"
484 msg = "The %s setting must be a list or a tuple."
485 for setting in self.list_or_tuple_settings:
486 setattr(settings_module, setting, ("non_list_or_tuple_value"))
487 sys.modules["fake_settings_module"] = settings_module
488 try:
489 with self.assertRaisesMessage(ImproperlyConfigured, msg % setting):
490 Settings("fake_settings_module")
491 finally:
492 del sys.modules["fake_settings_module"]
493 delattr(settings_module, setting)
494
495
496 class SettingChangeEnterException(Exception):
497 pass
498
499
500 class SettingChangeExitException(Exception):
501 pass
502
503
504 class OverrideSettingsIsolationOnExceptionTests(SimpleTestCase):
505 """
506 The override_settings context manager restore settings if one of the
507 receivers of "setting_changed" signal fails. Check the three cases of
508 receiver failure detailed in receiver(). In each case, ALL receivers are
509 called when exiting the context manager.
510 """
511
512 def setUp(self):
513 signals.setting_changed.connect(self.receiver)
514 self.addCleanup(signals.setting_changed.disconnect, self.receiver)
515 # Create a spy that's connected to the `setting_changed` signal and
516 # executed AFTER `self.receiver`.
517 self.spy_receiver = mock.Mock()
518 signals.setting_changed.connect(self.spy_receiver)
519 self.addCleanup(signals.setting_changed.disconnect, self.spy_receiver)
520
521 def receiver(self, **kwargs):
522 """
523 A receiver that fails while certain settings are being changed.
524 - SETTING_BOTH raises an error while receiving the signal
525 on both entering and exiting the context manager.
526 - SETTING_ENTER raises an error only on enter.
527 - SETTING_EXIT raises an error only on exit.
528 """
529 setting = kwargs["setting"]
530 enter = kwargs["enter"]
531 if setting in ("SETTING_BOTH", "SETTING_ENTER") and enter:
532 raise SettingChangeEnterException
533 if setting in ("SETTING_BOTH", "SETTING_EXIT") and not enter:
534 raise SettingChangeExitException
535
536 def check_settings(self):
537 """Assert that settings for these tests aren't present."""
538 self.assertFalse(hasattr(settings, "SETTING_BOTH"))
539 self.assertFalse(hasattr(settings, "SETTING_ENTER"))
540 self.assertFalse(hasattr(settings, "SETTING_EXIT"))
541 self.assertFalse(hasattr(settings, "SETTING_PASS"))
542
543 def check_spy_receiver_exit_calls(self, call_count):
544 """
545 Assert that `self.spy_receiver` was called exactly `call_count` times
546 with the ``enter=False`` keyword argument.
547 """
548 kwargs_with_exit = [
549 kwargs
550 for args, kwargs in self.spy_receiver.call_args_list
551 if ("enter", False) in kwargs.items()
552 ]
553 self.assertEqual(len(kwargs_with_exit), call_count)
554
555 def test_override_settings_both(self):
556 """Receiver fails on both enter and exit."""
557 with self.assertRaises(SettingChangeEnterException):
558 with override_settings(SETTING_PASS="BOTH", SETTING_BOTH="BOTH"):
559 pass
560
561 self.check_settings()
562 # Two settings were touched, so expect two calls of `spy_receiver`.
563 self.check_spy_receiver_exit_calls(call_count=2)
564
565 def test_override_settings_enter(self):
566 """Receiver fails on enter only."""
567 with self.assertRaises(SettingChangeEnterException):
568 with override_settings(SETTING_PASS="ENTER", SETTING_ENTER="ENTER"):
569 pass
570
571 self.check_settings()
572 # Two settings were touched, so expect two calls of `spy_receiver`.
573 self.check_spy_receiver_exit_calls(call_count=2)
574
575 def test_override_settings_exit(self):
576 """Receiver fails on exit only."""
577 with self.assertRaises(SettingChangeExitException):
578 with override_settings(SETTING_PASS="EXIT", SETTING_EXIT="EXIT"):
579 pass
580
581 self.check_settings()
582 # Two settings were touched, so expect two calls of `spy_receiver`.
583 self.check_spy_receiver_exit_calls(call_count=2)
584
585 def test_override_settings_reusable_on_enter(self):
586 """
587 Error is raised correctly when reusing the same override_settings
588 instance.
589 """
590
591 @override_settings(SETTING_ENTER="ENTER")
592 def decorated_function():
593 pass
594
595 with self.assertRaises(SettingChangeEnterException):
596 decorated_function()
597 signals.setting_changed.disconnect(self.receiver)
598 # This call shouldn't raise any errors.
599 decorated_function()
600
601
602 class MediaURLStaticURLPrefixTest(SimpleTestCase):
603 def set_script_name(self, val):
604 clear_script_prefix()
605 if val is not None:
606 set_script_prefix(val)
607
608 def test_not_prefixed(self):
609 # Don't add SCRIPT_NAME prefix to absolute paths, URLs, or None.
610 tests = (
611 "/path/",
612 "http://myhost.com/path/",
613 "http://myhost/path/",
614 "https://myhost/path/",
615 None,
616 )
617 for setting in ("MEDIA_URL", "STATIC_URL"):
618 for path in tests:
619 new_settings = {setting: path}
620 with self.settings(**new_settings):
621 for script_name in ["/somesubpath", "/somesubpath/", "/", "", None]:
622 with self.subTest(script_name=script_name, **new_settings):
623 try:
624 self.set_script_name(script_name)
625 self.assertEqual(getattr(settings, setting), path)
626 finally:
627 clear_script_prefix()
628
629 def test_add_script_name_prefix(self):
630 tests = (
631 # Relative paths.
632 ("/somesubpath", "path/", "/somesubpath/path/"),
633 ("/somesubpath/", "path/", "/somesubpath/path/"),
634 ("/", "path/", "/path/"),
635 # Invalid URLs.
636 (
637 "/somesubpath/",
638 "htp://myhost.com/path/",
639 "/somesubpath/htp://myhost.com/path/",
640 ),
641 # Blank settings.
642 ("/somesubpath/", "", "/somesubpath/"),
643 )
644 for setting in ("MEDIA_URL", "STATIC_URL"):
645 for script_name, path, expected_path in tests:
646 new_settings = {setting: path}
647 with self.settings(**new_settings):
648 with self.subTest(script_name=script_name, **new_settings):
649 try:
650 self.set_script_name(script_name)
651 self.assertEqual(getattr(settings, setting), expected_path)
652 finally:
653 clear_script_prefix()