Django est livré avec sa propre suite de tests, dans le répertoire tests de la base de code. Notre politique est de nous assurer que tous les tests passent en tout temps.
Nous apprécions toute contribution à la suite de tests !
\nLes tests de Django utilisent tous l’infrastructure de tests livrée avec Django pour tester les applications. Consultez Écriture et lancement de tests pour une explication sur la façon d’écrire de nouveaux tests.
\nTout d’abord, créez votre fork de Django sur GitHub.
\nEnsuite, créez et activez un environnement virtuel. Si vous n’êtes pas familier avec cette procédure, lisez le tutoriel de contribution.
\nPuis, créez un clone local de votre fork, installez quelques dépendances et lancez la suite de tests
\n$ git clone git@github.com:YourGitHubName/django.git django-repo\n$ cd django-repo/tests\n$ pip install -e ..\n$ pip install -r requirements/py3.txt\n$ ./runtests.py\nL’installation des dépendances nécessite probablement l’installation de paquets de votre système d’exploitation. Il est généralement possible de savoir quels paquets installer en faisant une recherche Web à propos des dernières lignes du message d’erreur. Essayez d’ajouter le nom de votre système d’exploitation à la requête si nécessaire.
\nSi vous avez des soucis d’installation des dépendances, vous pouvez omettre cette étape. Voir Running all the tests pour des détails sur l’installation des dépendances facultatives des tests. Si l’une des dépendances facultatives n’est pas installée, les tests qui l’exigent seront passés (skipped).
\nLe lancement des tests exige un module de réglages Django définissant la base de données à utiliser. Pour faciliter le démarrage, Django fournit et utilise un module de réglages d’exemple utilisant la base de données SQLite. Voir Utilisation d’un autre module de réglages settings pour apprendre comment utiliser un module de réglages différent pour lancer les tests avec une autre base de données.
\n\nDes problèmes ? Voir Dépannage pour certaines problématiques courantes.
\ntoxLien vers cette rubrique#Tox is a tool for running tests in different\nvirtual environments. Django includes a basic tox.ini that automates some\nchecks that our build server performs on pull requests. To run the unit tests\nand other checks (such as import sorting, the\ndocumentation spelling checker, and\ncode formatting), install and run the tox\ncommand from any place in the Django source tree:
$ pip install tox\n$ tox\nBy default, tox runs the test suite with the bundled test settings file for\nSQLite, flake8, isort, and the documentation spelling checker. In\naddition to the system dependencies noted elsewhere in this documentation,\nthe command python3 must be on your path and linked to the appropriate\nversion of Python. A list of default environments can be seen as follows:
$ tox -l\npy3\nflake8\ndocs\nisort\nIn addition to the default environments, tox supports running unit tests\nfor other versions of Python and other database backends. Since Django’s test\nsuite doesn’t bundle a settings file for database backends other than SQLite,\nhowever, you must create and provide your own test settings. For example, to run the tests on Python 3.5\nusing PostgreSQL:
$ tox -e py35-postgres -- --settings=my_postgres_settings\nThis command sets up a Python 3.5 virtual environment, installs Django’s\ntest suite dependencies (including those for PostgreSQL), and calls\nruntests.py with the supplied arguments (in this case,\n--settings=my_postgres_settings).
The remainder of this documentation shows commands for running tests without\ntox, however, any option passed to runtests.py can also be passed to\ntox by prefixing the argument list with --, as above.
Tox also respects the DJANGO_SETTINGS_MODULE environment variable, if set.\nFor example, the following is equivalent to the command above:
$ DJANGO_SETTINGS_MODULE=my_postgres_settings tox -e py35-postgres\nDjango includes a set of JavaScript unit tests for\nfunctions in certain contrib apps. The JavaScript tests aren’t run by default\nusing tox because they require Node.js to be installed and aren’t\nnecessary for the majority of patches. To run the JavaScript tests using\ntox:
$ tox -e javascript\nThis command runs npm install to ensure test requirements are up to\ndate and then runs npm test.
settingsLien vers cette rubrique#Le module de réglages inclus (tests/test_sqlite.py) permet de lancer la suite de tests avec SQLite. Si vous souhaitez lancer les tests avec une autre base de données, vous devez définir votre propre fichier de réglages. Certains tests, comme ceux de contrib.postgres, sont spécifique à un moteur de base de données spécifique et seront omis quand une autre base de données est utilisée.
Pour lancer les tests avec des réglages différents, assurez-vous que le module se trouve dans le chemin PYTHONPATH et indiquez ce module avec --settings.
Le réglage DATABASES dans tout module de réglages pour les tests doit définir deux bases de données :
Une base de données default. Celle-ci doit utiliser le moteur que vous souhaitez tester de manière principale.
Une base de données avec l’alias other. Celle-ci est utilisée pour tester les requêtes qui sont dirigées vers d’autres bases de données. Elle devrait utiliser le même moteur que la base de données default, mais elle doit avoir un autre nom.
Si vous utilisez un moteur autre que SQLite, il est nécessaire de fournir d’autres détails pour chaque base de données :
\nL’option USER doit indiquer un compte utilisateur existant pour la base de données. Cet utilisateur a besoin de la permission d’exécuter CREATE DATABASE afin de pouvoir créer la base de données de test.
L’option PASSWORD doit indiquer le mot de passe à utiliser pour l’utilisateur USER.
Test databases get their names by prepending test_ to the value of the\nNAME settings for the databases defined in DATABASES.\nThese test databases are deleted when the tests are finished.
You will also need to ensure that your database uses UTF-8 as the default\ncharacter set. If your database server doesn’t use UTF-8 as a default charset,\nyou will need to include a value for CHARSET in the\ntest settings dictionary for the applicable database.
Django’s entire test suite takes a while to run, and running every single test\ncould be redundant if, say, you just added a test to Django that you want to\nrun quickly without running everything else. You can run a subset of the unit\ntests by appending the names of the test modules to runtests.py on the\ncommand line.
For example, if you’d like to run tests only for generic relations and\ninternationalization, type:
\n$ ./runtests.py --settings=path.to.settings generic_relations i18n\nHow do you find out the names of individual tests? Look in tests/ — each\ndirectory name there is the name of a test.
If you just want to run a particular class of tests, you can specify a list of\npaths to individual test classes. For example, to run the TranslationTests\nof the i18n module, type:
$ ./runtests.py --settings=path.to.settings i18n.tests.TranslationTests\nGoing beyond that, you can specify an individual test method like this:
\n$ ./runtests.py --settings=path.to.settings i18n.tests.TranslationTests.test_lazy_objects\nSome tests require Selenium and a Web browser. To run these tests, you must\ninstall the selenium package and run the tests with the\n--selenium=<BROWSERS> option. For example, if you have Firefox and Google\nChrome installed:
$ ./runtests.py --selenium=firefox,chrome\nSee the selenium.webdriver package for the list of available browsers.
\nSpecifying --selenium automatically sets --tags=selenium to run only\nthe tests that require selenium.
If you want to run the full suite of tests, you’ll need to install a number of\ndependencies:
\nargon2-cffi 16.1.0+
jinja2 2.7+
pytz (required)
memcached, plus a supported Python binding
You can find these dependencies in pip requirements files inside the\ntests/requirements directory of the Django source tree and install them\nlike so:
$ pip install -r tests/requirements/py3.txt\nSi vous rencontrez une erreur durant l’installation, il est possible qu’une dépendance pour un ou plusieurs paquets Python manque sur votre système. Consultez la documentation du paquet problématique ou recherchez sur le Web avec le message d’erreur obtenu.
\nYou can also install the database adapter(s) of your choice using\noracle.txt, mysql.txt, or postgres.txt.
If you want to test the memcached cache backend, you’ll also need to define\na CACHES setting that points at your memcached instance.
To run the GeoDjango tests, you will need to setup a spatial database\nand install the Geospatial libraries.
\nEach of these dependencies is optional. If you’re missing any of them, the\nassociated tests will be skipped.
\nContributors are encouraged to run coverage on the test suite to identify areas\nthat need additional tests. The coverage tool installation and use is described\nin testing code coverage.
\nCoverage should be run in a single process to obtain accurate statistics. To\nrun coverage on the Django test suite using the standard test settings:
\n$ coverage run ./runtests.py --settings=test_sqlite --parallel=1\nAfter running coverage, generate the html report by running:
\n$ coverage html\nWhen running coverage for the Django tests, the included .coveragerc\nsettings file defines coverage_html as the output directory for the report\nand also excludes several directories not relevant to the results\n(test code or external code included in Django).
Les tests des applications contribuées se trouvent dans le répertoire tests/, typiquement sous <nom_app>_tests. Par exemple, les tests de contrib.auth se trouvent dans tests/auth_tests.
UnicodeEncodeErrorLien vers cette rubrique#Si le paquet locales n’est pas installé, certains tests échoueront avec une exception UnicodeEncodeError.
Il est possible de corriger cela par exemple sur les systèmes basés sur Debian en lançant
\n$ apt-get install locales\n$ dpkg-reconfigure locales\nIl est possible de corriger cela sur les systèmes macOS en configurant la locale du shell
\n$ export LANG="en_US.UTF-8"\n$ export LC_ALL="en_US.UTF-8"\nLancez la commande locale pour confirmer la modification. Une autre possibilité est d’ajouter ces commandes d’exportation au fichier de démarrage du shell (par ex. ~/.bashrc pour Bash) afin d’éviter de devoir les retaper.
In case a test passes when run in isolation but fails within the whole suite,\nwe have some tools to help analyze the problem.
\nThe --bisect option of runtests.py will run the failing test while\nhalving the test set it is run together with on each iteration, often making\nit possible to identify a small number of tests that may be related to the\nfailure.
For example, suppose that the failing test that works on its own is\nModelTest.test_eq, then using:
$ ./runtests.py --bisect basic.tests.ModelTest.test_eq\nwill try to determine a test that interferes with the given one. First, the\ntest is run with the first half of the test suite. If a failure occurs, the\nfirst half of the test suite is split in two groups and each group is then run\nwith the specified test. If there is no failure with the first half of the test\nsuite, the second half of the test suite is run with the specified test and\nsplit appropriately as described earlier. The process repeats until the set of\nfailing tests is minimized.
\nThe --pair option runs the given test alongside every other test from the\nsuite, letting you check if another test has side-effects that cause the\nfailure. So:
$ ./runtests.py --pair basic.tests.ModelTest.test_eq\nwill pair test_eq with every test label.
With both --bisect and --pair, if you already suspect which cases\nmight be responsible for the failure, you may limit tests to be cross-analyzed\nby specifying further test labels after\nthe first one:
$ ./runtests.py --pair basic.tests.ModelTest.test_eq queries transactions\nYou can also try running any set of tests in reverse using the --reverse\noption in order to verify that executing tests in a different order does not\ncause any trouble:
$ ./runtests.py basic --reverse\nIf you wish to examine the SQL being run in failing tests, you can turn on\nSQL logging using the --debug-sql option. If you\ncombine this with --verbosity=2, all SQL queries will be output:
$ ./runtests.py basic --debug-sql\nBy default tests are run in parallel with one process per core. When the tests\nare run in parallel, however, you’ll only see a truncated traceback for any\ntest failures. You can adjust this behavior with the --parallel option:
$ ./runtests.py basic --parallel=1\nYou can also use the DJANGO_TEST_PROCESSES environment variable for this\npurpose.
To avoid polluting the global apps registry and prevent\nunnecessary table creation, models defined in a test method should be bound to\na temporary Apps instance:
from django.apps.registry import Apps\nfrom django.db import models\nfrom django.test import SimpleTestCase\n\nclass TestModelDefinition(SimpleTestCase):\n def test_model_definition(self):\n test_apps = Apps(['app_label'])\n\n class TestModel(models.Model):\n class Meta:\n apps = test_apps\n ...\nSince this pattern involves a lot of boilerplate, Django provides the\nisolate_apps() decorator. It’s used like this:
from django.db import models\nfrom django.test import SimpleTestCase\nfrom django.test.utils import isolate_apps\n\nclass TestModelDefinition(SimpleTestCase):\n @isolate_apps('app_label')\n def test_model_definition(self):\n class TestModel(models.Model):\n pass\n ...\nThe decorator can also be applied to classes:
\nfrom django.db import models\nfrom django.test import SimpleTestCase\nfrom django.test.utils import isolate_apps\n\n@isolate_apps('app_label')\nclass TestModelDefinition(SimpleTestCase):\n def test_model_definition(self):\n class TestModel(models.Model):\n pass\n ...\nThe temporary Apps instance used to isolate model registration can be\nretrieved as an attribute when used as a class decorator by using the\nattr_name parameter:
from django.db import models\nfrom django.test import SimpleTestCase\nfrom django.test.utils import isolate_apps\n\n@isolate_apps('app_label', attr_name='apps')\nclass TestModelDefinition(SimpleTestCase):\n def test_model_definition(self):\n class TestModel(models.Model):\n pass\n self.assertIs(self.apps.get_model('app_label', 'TestModel'), TestModel)\nOr as an argument on the test method when used as a method decorator by using\nthe kwarg_name parameter:
from django.db import models\nfrom django.test import SimpleTestCase\nfrom django.test.utils import isolate_apps\n\nclass TestModelDefinition(SimpleTestCase):\n @isolate_apps('app_label', kwarg_name='apps')\n def test_model_definition(self, apps):\n class TestModel(models.Model):\n pass\n self.assertIs(apps.get_model('app_label', 'TestModel'), TestModel)\n