Best way to change the value of "settings" from within a Python test case?

Question

I'm writing unit tests in Python for the first time, for a Django app. I've struck a problem. In order to test a particular piece of functionality, I need to change the value of one of the app's settings. Here's my first attempt:

def test_in_list(self):
    mango.settings.META_LISTS = ('tags',)
    tags = Document(filepath).meta['tags']
    self.assertEqual(tags, [u'Markdown', u'Django', u'Mango'])

What I'm trying to do is change the value of META_LISTS such that the new value is used when the Document object is created. The relevant imports are...

# tests.py
from mango.models import Document
import mango.settings

# models.py
from mango.settings import *

If I've understood correctly, since models.py has already imported the names from mango.settings, changing the value of META_LISTS within mango.settings will not alter the value of META_LISTS within mango.models.

It's possible – likely even – that I'm going about this in completely the wrong way. What's the correct way to alter the value of such a "setting" from within a test case?

Edit: I failed to mention that the file models.py contains vanilla Python classes rather than Django models. I certainly need to rename this file!

Answer 1

In models.py, use import mango.settings. You can then set a variable in your test code like you would any other:

mango.settings.foo = 'bar'

A module is a singleton. You can change the values in its namespace from anywhere in your code.

But this won't work if you use from mango.settings import *, since that expression copies the values in the module into the current namespace.

Answer 2

Will this setting be used throughout the tests? In that case one solution would be to create a settings file for testing. For e.g. add a settings_for_tests.py.

# settings_for_tests.py
from settings import * # Get everything from default settings file.

# Override just what is required.
META_LISTS = ('tags',)

And then run your tests thus:

$ python ./manage.py test mango --settings=settings_for_tests

This will ensure that the models in the test database get created using the test settings and not the default settings.

If you are doing this it also makes sense to move the settings files inside a directory. For e.g.

project
  |
  |_ settings
  |    |
  |    |_ __init__.py # Contains merely from settings import *
  |    |_ settings.py
  |    |_ settings_for_tests.py
  |
  |_ apps
       |

Answer 3

There's a simpler way to do this.

Use multiple settings files -- each under proper configuration control.

We do this.

1. We have a master settings module that has the "applies always" settings. Middleware, installed applications, other settings unique to our applications.

2. We have "subclass" settings which (a) import the master settings and then (b) introduce platform-specific (or stage-specific, or customer-specific) settings. This is where our Windows file path stuff is isolated. Plus the locations of the static media files. Plus customer-specific template paths, etc.

3. We break our test scripts into several parts. The "default' tests.py does basic model, form and view-function tests that must work on all platforms, all development stages (dev, test, qa, etc.) and all customers.

4. We have separate unit test scripts which require special settings for particularly complex fixtures. These are not in tests.py and don't run automatically. They require An explicit call to Django's utilities to setup and teardown test environments.

See http://docs.djangoproject.com/en/1.2/topics/testing/#module-django.test.utils

---

how you would recommend testing a silly function which returns "hello" when a particular setting is truthy, and "goodbye" when falsy

This may be an indication of a poor design. Test-Driven Design (TDD) suggests that you should have designed this so that it's testable without an elaborate, complex setup.

If you must do it through settings, what are you really tesing? That the settings values propagate into your code? That's silly. You should trust that the framework works. Indeed, you have to assume the framework works, otherwise, you're obligated to test every feature of the framework.

You should have a function which accepts settings.SOME_SETTING as an argument so that you can test it as a stand-alone unit without fussing around to get the entire environment correct. You have to trust that the environment and framework actually work.

Answer 4

For changing settings in TestCases i use modified version of this snippet http://www.djangosnippets.org/snippets/1011/

Here is my modification of this snippet http://github.com/dominno/django-moderation/blob/master/src/moderation/tests/utils/testsettingsmanager.py

Then i create file with my test settings and then i use(example from my project):

class SerializationTestCase(SettingsTestCase):
    fixtures = ['test_users.json', 'test_moderation.json']
    test_settings = 'moderation.tests.settings.generic'

    def setUp(self):
        self.user = User.objects.get(username='moderator')
        self.profile = UserProfile.objects.get(user__username='moderator')

    def test_serialize_of_object(self):
        """Test if object is propertly serialized to json"""

        json_field = SerializedObjectField()

        self.assertEqual(json_field._serialize(self.profile),
                    '[{"pk": 1, "model": "test_app.userprofile", "fields": '\
                    '{"url": "http://www.google.com", "user": 1, '\
                    '"description": "Old description"}}]',
                         )

It will keep track of the original settings and let easily revert them back when test is finished.