Wie kann ich mit verschiedenen Einstellungen in Django Unit-Tests durchführen?

Gibt es einen einfachen Mechanismus zum Überschreiben von Django-Einstellungen für einen Komponententest? Ich habe einen Manager für eines meiner Modelle, der eine bestimmte Anzahl der neuesten Objekte zurückgibt. Die Anzahl der zurückgegebenen Objekte wird durch eine NUM_LATEST-Einstellung definiert.

Dies kann dazu führen, dass meine Tests fehlschlagen, wenn jemand die Einstellung ändert. Wie kann ich die Einstellungen überschreiben setUp()und anschließend wiederherstellen tearDown()? Wenn das nicht möglich ist, gibt es eine Möglichkeit, die Methode zu patchen oder die Einstellungen zu verspotten?

EDIT: Hier ist mein Manager-Code:

class LatestManager(models.Manager):
    """
    Returns a specific number of the most recent public Articles as defined by 
    the NEWS_LATEST_MAX setting.
    """
    def get_query_set(self):
        num_latest = getattr(settings, 'NEWS_NUM_LATEST', 10)
        return super(LatestManager, self).get_query_set().filter(is_public=True)[:num_latest]

Der Manager settings.NEWS_LATEST_MAXschneidet das Abfrageset. Das getattr()wird einfach verwendet, um eine Standardeinstellung anzugeben, falls die Einstellung nicht vorhanden ist.

BEARBEITEN: Diese Antwort gilt, wenn Sie die Einstellungen für eine kleine Anzahl spezifischer Tests ändern möchten .

Seit Django 1.4 gibt es Möglichkeiten, Einstellungen während Tests zu überschreiben: https://docs.djangoproject.com/de/dev/topics/testing/tools/#overriding-settings

TestCase verfügt über einen Kontextmanager für self.settings und einen @ override_settings-Dekorator, der entweder auf eine Testmethode oder eine gesamte TestCase-Unterklasse angewendet werden kann.

Diese Funktionen gab es in Django 1.3 noch nicht.

Wenn Sie die Einstellungen für alle Ihre Tests ändern möchten , müssen Sie eine separate Einstellungsdatei für den Test erstellen, in der Einstellungen aus Ihrer Haupteinstellungsdatei geladen und überschrieben werden können. In den anderen Antworten gibt es mehrere gute Ansätze dafür; Ich habe erfolgreiche Variationen sowohl der Ansätze von hspander als auch von dmitrii gesehen .

Sie können mit der UnitTestUnterklasse alles tun, was Sie möchten, einschließlich des Festlegens und Lesens von Instanzeigenschaften:

from django.conf import settings

class MyTest(unittest.TestCase):
   def setUp(self):
       self.old_setting = settings.NUM_LATEST
       settings.NUM_LATEST = 5 # value tested against in the TestCase

   def tearDown(self):
       settings.NUM_LATEST = self.old_setting

Da die Django-Testfälle jedoch mit einem Thread ausgeführt werden, bin ich gespannt, was den NUM_LATEST-Wert sonst noch ändern könnte. Wenn dieses "etwas anderes" von Ihrer Testroutine ausgelöst wird, bin ich mir nicht sicher, ob durch das Patchen von Affen der Test gespeichert wird, ohne die Richtigkeit der Tests selbst zu beeinträchtigen.

Obwohl das Überschreiben der Konfiguration der Einstellungen zur Laufzeit hilfreich sein kann, sollten Sie meiner Meinung nach eine separate Datei zum Testen erstellen. Dies spart viel Konfiguration für Tests und würde sicherstellen, dass Sie niemals etwas Irreversibles tun (wie das Bereinigen der Staging-Datenbank).

Angenommen, Ihre Testdatei befindet sich in 'my_project / test_settings.py', fügen Sie hinzu

settings = 'my_project.test_settings' if 'test' in sys.argv else 'my_project.settings'

in Ihrer manage.py. Dadurch wird sichergestellt, dass Sie beim python manage.py testAusführen nur test_settings verwenden. Wenn Sie einen anderen Testclient wie pytest verwenden, können Sie diesen genauso einfach zu pytest.ini hinzufügen

Sie können die --settingsOption beim Ausführen von Tests übergeben

python manage.py test --settings=mysite.settings_local

Update : Die folgende Lösung wird nur für Django 1.3.x und früher benötigt. Für> 1.4 siehe die Antwort von slinkp .

Wenn Sie in Ihren Tests häufig Einstellungen ändern und Python ≥2,5 verwenden, ist dies auch praktisch:

from contextlib import contextmanager

class SettingDoesNotExist:
    pass

@contextmanager
def patch_settings(**kwargs):
    from django.conf import settings
    old_settings = []
    for key, new_value in kwargs.items():
        old_value = getattr(settings, key, SettingDoesNotExist)
        old_settings.append((key, old_value))
        setattr(settings, key, new_value)
    yield
    for key, old_value in old_settings:
        if old_value is SettingDoesNotExist:
            delattr(settings, key)
        else:
            setattr(settings, key, old_value)

Dann können Sie tun:

with patch_settings(MY_SETTING='my value', OTHER_SETTING='other value'):
    do_my_tests()

@override_settings ist großartig, wenn Sie nicht viele Unterschiede zwischen Ihren Produktions- und Testumgebungskonfigurationen haben.

In anderen Fällen sollten Sie nur andere Einstellungsdateien haben. In diesem Fall sieht Ihr Projekt folgendermaßen aus:

your_project
    your_app
        ...
    settings
        __init__.py
        base.py
        dev.py
        test.py
        production.py
    manage.py

Sie müssen also die meisten Einstellungen in base.pyund dann in anderen Dateien haben, um alles von dort zu importieren und einige Optionen zu überschreiben. So test.pysieht Ihre Datei aus:

from .base import *

DEBUG = False

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

PASSWORD_HASHERS = (
    'django.contrib.auth.hashers.MD5PasswordHasher',
)

LOGGING = {}

Und dann müssen Sie entweder die --settingsOption wie in der Antwort von @MicroPyramid angeben oder die DJANGO_SETTINGS_MODULEUmgebungsvariable angeben , und dann können Sie Ihre Tests ausführen:

export DJANGO_SETTINGS_MODULE=settings.test
python manage.py test 

Dies wurde beim Versuch gefunden, einige Doctests zu korrigieren ... Der Vollständigkeit halber möchte ich erwähnen, dass Sie dies tun sollten, bevor Sie etwas anderes importieren, wenn Sie die Einstellungen bei der Verwendung von Doctests ändern möchten ...

>>> from django.conf import settings

>>> settings.SOME_SETTING = 20

>>> # Your other imports
>>> from django.core.paginator import Paginator
>>> # etc

Für Pytest- Benutzer.

Das größte Problem ist:

• override_settings funktioniert nicht mit pytest.
• Wenn Sie Djangos TestCaseunterordnen, funktioniert es, aber dann können Sie keine Pytest-Geräte verwenden.

Die Lösung besteht darin, das hiersettings dokumentierte Gerät zu verwenden .

Beispiel

def test_with_specific_settings(settings):
    settings.DEBUG = False
    settings.MIDDLEWARE = []
    ..

Und falls Sie mehrere Felder aktualisieren müssen

def override_settings(settings, kwargs):
    for k, v in kwargs.items():
        setattr(settings, k, v)


new_settings = dict(
    DEBUG=True,
    INSTALLED_APPS=[],
)


def test_with_specific_settings(settings):
    override_settings(settings, new_settings)

Ich benutze Pytest.

Ich habe es folgendermaßen geschafft:

import django    
import app.setting
import modules.that.use.setting

# do some stuff with default setting
setting.VALUE = "some value"
django.setup()
import importlib
importlib.reload(app.settings)
importlib.reload(modules.that.use.setting)
# do some stuff with settings new value

Sie können die Einstellungen im Test folgendermaßen überschreiben:

from django.test import TestCase, override_settings

test_settings = override_settings(
    DEFAULT_FILE_STORAGE='django.core.files.storage.FileSystemStorage',
    PASSWORD_HASHERS=(
        'django.contrib.auth.hashers.UnsaltedMD5PasswordHasher',
    )
)


@test_settings
class SomeTestCase(TestCase):
    """Your test cases in this class"""

Und wenn Sie dieselben Einstellungen in einer anderen Datei benötigen, können Sie diese direkt importieren test_settings.

Sie können die Einstellung auch für eine einzelne Testfunktion überschreiben.

from django.test import TestCase, override_settings

class SomeTestCase(TestCase):

    @override_settings(SOME_SETTING="some_value")
    def test_some_function():
        

oder Sie können die Einstellung für jede Funktion in der Klasse überschreiben.

@override_settings(SOME_SETTING="some_value")
class SomeTestCase(TestCase):

    def test_some_function():
        

Wenn Sie mehrere Testdateien in einem Unterverzeichnis (Python-Paket) abgelegt haben, können Sie die Einstellungen für alle diese Dateien basierend auf der Bedingung des Vorhandenseins einer Testzeichenfolge in sys.argv überschreiben

app
  tests
    __init__.py
    test_forms.py
    test_models.py

__init__.py:

import sys
from project import settings

if 'test' in sys.argv:
    NEW_SETTINGS = {
        'setting_name': value,
        'another_setting_name': another_value
    }
    settings.__dict__.update(NEW_SETTINGS)

Nicht der beste Ansatz. Verwendet es, um den Sellerie-Broker von Redis in Memory zu ändern.

Ich habe eine neue Datei settings_test.py erstellt, die alles aus der Datei settings.py importiert und zu Testzwecken alle Änderungen ändert. In meinem Fall wollte ich beim Testen einen anderen Cloud-Speicher-Bucket verwenden.

settings_test.py:

from project1.settings import *
import os

CLOUD_STORAGE_BUCKET = 'bucket_name_for_testing'

manage.py:

def main():

    # use seperate settings.py for tests
    if 'test' in sys.argv:
        print('using settings_test.py')
        os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'project1.settings_test')
    else:
        os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'project1.settings')

    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)