How to Unit Test with Different Settings in Django?

Unit testing is a part of developing robust Django applications. Quite often, there will be many scenarios where a test or some tests require applying different settings. Django provides tools to temporarily change settings for testing so that a developer can isolate test cases and make sure the code works properly under certain conditions. In this article, we will see how you can use various settings in your Django unit tests.

Using the override_settings Decorator

This override_settings decorator is a very useful tool in Django to make temporary changes in settings for the lifetime of a test case. This will be particularly useful in the case that you might want to test how your code performs under different configurations—and not just permanently alter your settings.

How it works

• The override_settings decorator goes directly above the test function itself.
• It takes keyword arguments where each key is a setting you want to override, and the value is what setting that is.
• Finally, after the test function has been executed, the original settings are restored.

Example usage

from django.test import TestCase, override_settings

class MyTestCase(TestCase):

    @override_settings(DEBUG=True)
    def test_debug_mode(self):
        self.assertTrue(settings.DEBUG)

    @override_settings(CACHE_TIMEOUT=60)
    def test_cache_timeout(self):
        self.assertEqual(settings.CACHE_TIMEOUT, 60)

Configuring Test Settings

Apart from using override_settings, Django lets you write a separate settings module for testing. This is beneficial where you need to use a quite completely different configuration for your test suite.

Steps to Configure Test Settings

1. Create a test_settings.py File:

• This will be a settings file with settings that are specific, thus overriding the normal settings.py file.
• It may contain various databases, caches, or other configuration items which are test-specific.

# test_settings.py
from .settings import *

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': ':memory:',
    }
}

DEBUG = False

2. Specify the Test Settings

• When running your tests, specify your test settings by passing the --settings flag or setting the DJANGO_SETTINGS_MODULE environment variable.

python manage.py test --settings=myproject.test_settings

OR

DJANGO_SETTINGS_MODULE=myproject.test_settings python manage.py test

Code Example

Let's put it all together in a practical example. Suppose you're working on a Django project where you need to test how your application behaves under different configurations of the cache.

from django.test import TestCase, override_settings
from django.core.cache import cache

class CacheSettingsTestCase(TestCase):

    @override_settings(CACHE_BACKEND='django.core.cache.backends.locmem.LocMemCache')
    def test_local_memory_cache(self):
        cache.set('my_key', 'value')
        self.assertEqual(cache.get('my_key'), 'value')

    @override_settings(CACHE_BACKEND='django.core.cache.backends.filebased.FileBasedCache',
                       CACHE_LOCATION='/tmp/test_cache')
    def test_file_based_cache(self):
        cache.set('my_key', 'value')
        self.assertEqual(cache.get('my_key'), 'value')

Output:

The tests run successfully. And like this, you can play with your settings variables and test your application smoothly.

Conclusion

Unit testing with different settings in Django is quite important to make sure that your application will work as one would expect it to in various conditions. The override_settings decorator and configuration of test-specific settings enable one to create flexible and solid test cases that help in the coverage of a wide scope of scenarios. Such tools help not only in catching potential issues at an early stage but also in increasing the quality and reliability of a Django project in general.

@override_settings(DEBUG=True, CACHE_TIMEOUT=60)
def test_multiple_settings(self):
    self.assertTrue(settings.DEBUG)
    self.assertEqual(settings.CACHE_TIMEOUT, 60)

3. What happens to the original settings after a test is executed?

Ans. Changes made for the test using override_settings are restored right after the test function finishes. This should not have any impact on other tests or on the configuration of the project as a whole.

4. Is it possible to revert a specific setting back to its original value within a test?

Ans. In case you need to revert some setting back to its initial value during a test, it's possible to store the old value before overriding it, and then manually set the value back in the test. Normally, it's much easier to just split the test into two separate test cases.