| 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() |