{"title":"Testing tools","version":"4.1","locale":"it","docname":"topics/testing/tools","url":"/it/4.1/topics/testing/tools/","canonical":"https://djangodocs.dev/it/4.1/topics/testing/tools/","summary":"Django provides a small set of tools that come in handy when writing tests. The test client Link to this heading # The test client is a Python class that acts as a…","html":"
The test client is a Python class that acts as a dummy web browser, allowing\nyou to test your views and interact with your Django-powered application\nprogrammatically.
\n
Some of the things you can do with the test client are:
\n
\n
Simulate GET and POST requests on a URL and observe the response –\neverything from low-level HTTP (result headers and status codes) to\npage content.
\n
See the chain of redirects (if any) and check the URL and status code at\neach step.
\n
Test that a given request is rendered by a given Django template, with\na template context that contains certain values.
\n
\n
Note that the test client is not intended to be a replacement for Selenium or\nother «in-browser» frameworks. Django’s test client has a different focus. In\nshort:
\n
\n
Use Django’s test client to establish that the correct template is being\nrendered and that the template is passed the correct context data.
\n
Use RequestFactory to test view functions directly,\nbypassing the routing and middleware layers.
\n
Use in-browser frameworks like Selenium to test rendered HTML and the\nbehavior of web pages, namely JavaScript functionality. Django also\nprovides special support for those frameworks; see the section on\nLiveServerTestCase for more details.
\n
\n
A comprehensive test suite should use a combination of all of these test types.
As this example suggests, you can instantiate Client from within a session\nof the Python interactive interpreter.
\n
Note a few important things about how the test client works:
\n
\n
The test client does not require the web server to be running. In fact,\nit will run just fine with no web server running at all! That’s because\nit avoids the overhead of HTTP and deals directly with the Django\nframework. This helps make the unit tests run quickly.
\n
When retrieving pages, remember to specify the path of the URL, not the\nwhole domain. For example, this is correct:
\n
Code
>>> c.get('/login/')\n
\n
This is incorrect:
\n
Code
>>> c.get('https://www.example.com/login/')\n
\n
The test client is not capable of retrieving web pages that are not\npowered by your Django project. If you need to retrieve other web pages,\nuse a Python standard library module such as urllib.
\n
\n
To resolve URLs, the test client uses whatever URLconf is pointed-to by\nyour ROOT_URLCONF setting.
\n
Although the above example would work in the Python interactive\ninterpreter, some of the test client’s functionality, notably the\ntemplate-related functionality, is only available while tests are\nrunning.
\n
The reason for this is that Django’s test runner performs a bit of black\nmagic in order to determine which template was loaded by a given view.\nThis black magic (essentially a patching of Django’s template system in\nmemory) only happens during test running.
\n
\n
By default, the test client will disable any CSRF checks\nperformed by your site.
\n
If, for some reason, you want the test client to perform CSRF\nchecks, you can create an instance of the test client that\nenforces CSRF checks. To do this, pass in the\nenforce_csrf_checks argument when you construct your\nclient:
Use the django.test.Client class to make requests.
\n
\n
\nclassClient(enforce_csrf_checks=False, raise_request_exception=True, json_encoder=DjangoJSONEncoder, **defaults)Link to this definition#
\n
It requires no arguments at time of construction. However, you can use\nkeyword arguments to specify some default headers. For example, this will\nsend a User-Agent HTTP header in each request:
\n
Code
>>> c=Client(HTTP_USER_AGENT='Mozilla/5.0')\n
\n
The values from the extra keyword arguments passed to\nget(),\npost(), etc. have precedence over\nthe defaults passed to the class constructor.
\n
The enforce_csrf_checks argument can be used to test CSRF\nprotection (see above).
\n
The raise_request_exception argument allows controlling whether or not\nexceptions raised during the request should also be raised in the test.\nDefaults to True.
\n
The json_encoder argument allows setting a custom JSON encoder for\nthe JSON serialization that’s described in post().
\n
Once you have a Client instance, you can call any of the following\nmethods:
…will send the HTTP header HTTP_ACCEPT to the details view, which\nis a good way to test code paths that use the\ndjango.http.HttpRequest.accepts() method.
\n\n
If you already have the GET arguments in URL-encoded form, you can\nuse that encoding instead of using the data argument. For example,\nthe previous GET request could also be posed as:
If you provide a URL with both an encoded GET data and a data argument,\nthe data argument will take precedence.
\n
If you set follow to True the client will follow any redirects\nand a redirect_chain attribute will be set in the response object\ncontaining tuples of the intermediate urls and status codes.
\n
If you had a URL /redirect_me/ that redirected to /next/, that\nredirected to /final/, this is what you’d see:
…will result in the evaluation of a POST request to this URL:
\n
Code
/login/\n
\n
…with this POST data:
\n
Code
name=fred&passwd=secret\n
\n
If you provide content_type as application/json, the\ndata is serialized using json.dumps() if it’s a dict, list,\nor tuple. Serialization is performed with\nDjangoJSONEncoder by default,\nand can be overridden by providing a json_encoder argument to\nClient. This serialization also happens for put(),\npatch(), and delete() requests.
\n
If you provide any other content_type (e.g. text/xml\nfor an XML payload), the contents of data are sent as-is in the\nPOST request, using content_type in the HTTP Content-Type\nheader.
\n
If you don’t provide a value for content_type, the values in\ndata will be transmitted with a content type of\nmultipart/form-data. In this case, the key-value pairs in\ndata will be encoded as a multipart message and used to create the\nPOST data payload.
\n
To submit multiple values for a given key – for example, to specify\nthe selections for a <selectmultiple> – provide the values as a\nlist or tuple for the required key. For example, this value of data\nwould submit three selected values for the field named choices:
\n
Code
{'choices':('a','b','d')}\n
\n
Submitting files is a special case. To POST a file, you need only\nprovide the file field name as a key, and a file handle to the file you\nwish to upload as a value. For example, if your form has fields\nname and attachment, the latter a\nFileField:
You may also provide any file-like object (e.g., StringIO or\nBytesIO) as a file handle. If you’re uploading to an\nImageField, the object needs a name\nattribute that passes the\nvalidate_image_file_extension validator.\nFor example:
Note that if you wish to use the same file handle for multiple\npost() calls then you will need to manually reset the file\npointer between posts. The easiest way to do this is to\nmanually close the file after it has been provided to\npost(), as demonstrated above.
\n
You should also ensure that the file is opened in a way that\nallows the data to be read. If your file contains binary data\nsuch as an image, this means you will need to open the file in\nrb (read binary) mode.
\n
The extra argument acts the same as for Client.get().
\n
If the URL you request with a POST contains encoded parameters, these\nparameters will be made available in the request.GET data. For example,\nif you were to make the request:
… the view handling this request could interrogate request.POST\nto retrieve the username and password, and could interrogate request.GET\nto determine if the user was a visitor.
\n
If you set follow to True the client will follow any redirects\nand a redirect_chain attribute will be set in the response object\ncontaining tuples of the intermediate urls and status codes.
\n
If you set secure to True the client will emulate an HTTPS\nrequest.
Makes a HEAD request on the provided path and returns a\nResponse object. This method works just like Client.get(),\nincluding the follow, secure and extra arguments, except\nit does not return a message body.
\n
\n\n
\n
\noptions(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)Link to this definition#
\n
Makes an OPTIONS request on the provided path and returns a\nResponse object. Useful for testing RESTful interfaces.
\n
When data is provided, it is used as the request body, and\na Content-Type header is set to content_type.
\n
The follow, secure and extra arguments act the same as for\nClient.get().
\n
\n\n
\n
\nput(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)Link to this definition#
\n
Makes a PUT request on the provided path and returns a\nResponse object. Useful for testing RESTful interfaces.
\n
When data is provided, it is used as the request body, and\na Content-Type header is set to content_type.
\n
The follow, secure and extra arguments act the same as for\nClient.get().
\n
\n\n
\n
\npatch(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)Link to this definition#
\n
Makes a PATCH request on the provided path and returns a\nResponse object. Useful for testing RESTful interfaces.
\n
The follow, secure and extra arguments act the same as for\nClient.get().
\n
\n\n
\n
\ndelete(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)Link to this definition#
\n
Makes a DELETE request on the provided path and returns a\nResponse object. Useful for testing RESTful interfaces.
\n
When data is provided, it is used as the request body, and\na Content-Type header is set to content_type.
\n
The follow, secure and extra arguments act the same as for\nClient.get().
Makes a TRACE request on the provided path and returns a\nResponse object. Useful for simulating diagnostic probes.
\n
Unlike the other request methods, data is not provided as a keyword\nparameter in order to comply with RFC 7231 Section 4.3.8, which\nmandates that TRACE requests must not have a body.
\n
The follow, secure, and extra arguments act the same as for\nClient.get().
If your site uses Django’s authentication system\nand you deal with logging in users, you can use the test client’s\nlogin() method to simulate the effect of a user logging into the\nsite.
\n
After you call this method, the test client will have all the cookies\nand session data required to pass any login-based tests that may form\npart of a view.
\n
The format of the credentials argument depends on which\nauthentication backend you’re using\n(which is configured by your AUTHENTICATION_BACKENDS\nsetting). If you’re using the standard authentication backend provided\nby Django (ModelBackend), credentials should be the user’s\nusername and password, provided as keyword arguments:
\n
Code
>>> c=Client()\n>>> c.login(username='fred',password='secret')\n\n# Now you can access a view that's only available to logged-in users.\n
\n
If you’re using a different authentication backend, this method may\nrequire different credentials. It requires whichever credentials are\nrequired by your backend’s authenticate() method.
\n
login() returns True if it the credentials were accepted and\nlogin was successful.
\n
Finally, you’ll need to remember to create user accounts before you can\nuse this method. As we explained above, the test runner is executed\nusing a test database, which contains no users by default. As a result,\nuser accounts that are valid on your production site will not work\nunder test conditions. You’ll need to create users as part of the test\nsuite – either manually (using the Django model API) or with a test\nfixture. Remember that if you want your test user to have a password,\nyou can’t set the user’s password by setting the password attribute\ndirectly – you must use the\nset_password() function to\nstore a correctly hashed password. Alternatively, you can use the\ncreate_user() helper\nmethod to create a new user with a correctly hashed password.
If your site uses Django’s authentication\nsystem, you can use the force_login() method\nto simulate the effect of a user logging into the site. Use this method\ninstead of login() when a test requires a user be logged in and\nthe details of how a user logged in aren’t important.
\n
Unlike login(), this method skips the authentication and\nverification steps: inactive users (is_active=False) are permitted to login\nand the user’s credentials don’t need to be provided.
\n
The user will have its backend attribute set to the value of the\nbackend argument (which should be a dotted Python path string), or\nto settings.AUTHENTICATION_BACKENDS[0] if a value isn’t provided.\nThe authenticate() function called by\nlogin() normally annotates the user like this.
\n
This method is faster than login() since the expensive\npassword hashing algorithms are bypassed. Also, you can speed up\nlogin() by using a weaker hasher while testing.
If your site uses Django’s authentication system,\nthe logout() method can be used to simulate the effect of a user\nlogging out of your site.
\n
After you call this method, the test client will have all the cookies\nand session data cleared to defaults. Subsequent requests will appear\nto come from an AnonymousUser.
The get() and post() methods both return a Response object. This\nResponse object is not the same as the HttpResponse object returned\nby Django views; the test response object has some additional data useful for\ntest code to verify.
\n
Specifically, a Response object has the following attributes:
The template Context instance that was used to render the template that\nproduced the response content.
\n
If the rendered page used multiple templates, then context will be a\nlist of Context objects, in the order in which they were rendered.
\n
Regardless of the number of templates used during rendering, you can\nretrieve context values using the [] operator. For example, the\ncontext variable name could be retrieved using:
A list of Template instances used to render the final content, in\nthe order they were rendered. For each template in the list, use\ntemplate.name to get the template’s file name, if the template was\nloaded from a file. (The name is a string such as\n'admin/index.html'.)
An instance of ResolverMatch for the response.\nYou can use the func attribute, for\nexample, to verify the view that served the response:
\n
Code
# my_view here is a function based view.\nself.assertEqual(response.resolver_match.func,my_view)\n\n# Class-based views need to compare the view_class, as the\n# functions generated by as_view() won't be equal.\nself.assertIs(response.resolver_match.func.view_class,MyView)\n
\n
If the given URL is not found, accessing this attribute will raise a\nResolver404 exception.
\n
\n\n
\n\n
As with a normal response, you can also access the headers through\nHttpResponse.headers. For example, you could determine the content\ntype of a response using response.headers['Content-Type'].
If you point the test client at a view that raises an exception and\nClient.raise_request_exception is True, that exception will be visible\nin the test case. You can then use a standard try...except block or\nassertRaises() to test for exceptions.
\n
The only exceptions that are not visible to the test client are\nHttp404,\nPermissionDenied, SystemExit, and\nSuspiciousOperation. Django catches these\nexceptions internally and converts them into the appropriate HTTP response\ncodes. In these cases, you can check response.status_code in your test.
\n
If Client.raise_request_exception is False, the test client will return a\n500 response as would be returned to a browser. The response has the attribute\nexc_info to provide information about the unhandled\nexception.
The test client is stateful. If a response returns a cookie, then that cookie\nwill be stored in the test client and sent with all subsequent get() and\npost() requests.
\n
Expiration policies for these cookies are not followed. If you want a cookie\nto expire, either delete it manually or create a new Client instance (which\nwill effectively delete all cookies).
\n
A test client has attributes that store persistent state information. You can\naccess these properties as part of a test condition.
A dictionary-like object containing session information. See the\nsession documentation for full details.
\n
To modify the session and then save it, it must be stored in a variable\nfirst (because a new SessionStore is created every time this property\nis accessed):
When testing applications that support internationalization and localization,\nyou might want to set the language for a test client request. The method for\ndoing so depends on whether or not the\nLocaleMiddleware is enabled.
\n
If the middleware is enabled, the language can be set by creating a cookie with\na name of LANGUAGE_COOKIE_NAME and a value of the language code:
\n
Code
fromdjango.confimportsettings\n\ndeftest_language_using_cookie(self):\n self.client.cookies.load({settings.LANGUAGE_COOKIE_NAME:'fr'})\n response=self.client.get('/')\n self.assertEqual(response.content,b"Bienvenue sur mon site.")\n
\n
or by including the Accept-Language HTTP header in the request:
\n
Code
deftest_language_using_header(self):\n response=self.client.get('/',HTTP_ACCEPT_LANGUAGE='fr')\n self.assertEqual(response.content,b"Bienvenue sur mon site.")\n
The following is a unit test using the test client:
\n
Code
importunittest\nfromdjango.testimportClient\n\nclassSimpleTest(unittest.TestCase):\n defsetUp(self):\n # Every test needs a client.\n self.client=Client()\n\n deftest_details(self):\n # Issue a GET request.\n response=self.client.get('/customer/details/')\n\n # Check that the response is 200 OK.\n self.assertEqual(response.status_code,200)\n\n # Check that the rendered context contains 5 customers.\n self.assertEqual(len(response.context['customers']),5)\n
You can convert a normal unittest.TestCase to any of the subclasses:\nchange the base class of your test from unittest.TestCase to the subclass.\nAll of the standard Python unit test functionality will be available, and it\nwill be augmented with some useful additions as described in each section\nbelow.
SimpleTestCase disallows database queries by default. This\nhelps to avoid executing write queries which will affect other tests\nsince each SimpleTestCase test isn’t run in a transaction. If you\naren’t concerned about this problem, you can disable this behavior by\nsetting the databases class attribute to '__all__' on your test\nclass.
Django’s TestCase class is a more commonly used subclass of\nTransactionTestCase that makes use of database transaction facilities\nto speed up the process of resetting the database to a known state at the\nbeginning of each test. A consequence of this, however, is that some database\nbehaviors cannot be tested within a Django TestCase class. For instance,\nyou cannot test that a block of code is executing within a transaction, as is\nrequired when using\nselect_for_update(). In those cases,\nyou should use TransactionTestCase.
\n
TransactionTestCase and TestCase are identical except for the manner\nin which the database is reset to a known state and the ability for test code\nto test the effects of commit and rollback:
\n
\n
A TransactionTestCase resets the database after the test runs by\ntruncating all tables. A TransactionTestCase may call commit and rollback\nand observe the effects of these calls on the database.
\n
A TestCase, on the other hand, does not truncate tables after a test.\nInstead, it encloses the test code in a database transaction that is rolled\nback at the end of the test. This guarantees that the rollback at the end of\nthe test restores the database to its initial state.
This is the most common class to use for writing tests in Django. It inherits\nfrom TransactionTestCase (and by extension SimpleTestCase).\nIf your Django application doesn’t use a database, use SimpleTestCase.
\n
The class:
\n
\n
Wraps the tests within two nested atomic()\nblocks: one for the whole class and one for each test. Therefore, if you want\nto test some specific database transaction behavior, use\nTransactionTestCase.
\n
Checks deferrable database constraints at the end of each test.
The class-level atomic block described above allows the creation of\ninitial data at the class level, once for the whole TestCase. This\ntechnique allows for faster tests as compared to using setUp().
\n
For example:
\n
Code
fromdjango.testimportTestCase\n\nclassMyTests(TestCase):\n @classmethod\n defsetUpTestData(cls):\n # Set up data for the whole TestCase\n cls.foo=Foo.objects.create(bar="Test")\n ...\n\n deftest1(self):\n # Some test using self.foo\n ...\n\n deftest2(self):\n # Some other test using self.foo\n ...\n
\n
Note that if the tests are run on a database with no transaction support\n(for instance, MySQL with the MyISAM engine), setUpTestData() will be\ncalled before each test, negating the speed benefits.
\n
Objects assigned to class attributes in setUpTestData() must support\ncreating deep copies with copy.deepcopy() in order to isolate them\nfrom alterations performed by each test methods.
\n
\n\n
\n
\nclassmethodTestCase.captureOnCommitCallbacks(using=DEFAULT_DB_ALIAS, execute=False)Link to this definition#
\n
Returns a context manager that captures transaction.on_commit() callbacks for the given database\nconnection. It returns a list that contains, on exit of the context, the\ncaptured callback functions. From this list you can make assertions on the\ncallbacks or call them to invoke their side effects, emulating a commit.
\n
using is the alias of the database connection to capture callbacks for.
\n
If execute is True, all the callbacks will be called as the context\nmanager exits, if no exception occurred. This emulates a commit after the\nwrapped block of code.
\n
For example:
\n
Code
fromdjango.coreimportmail\nfromdjango.testimportTestCase\n\n\nclassContactTests(TestCase):\n deftest_post(self):\n withself.captureOnCommitCallbacks(execute=True)ascallbacks:\n response=self.client.post(\n '/contact/',\n {'message':'I like your site'},\n )\n\n self.assertEqual(response.status_code,200)\n self.assertEqual(len(callbacks),1)\n self.assertEqual(len(mail.outbox),1)\n self.assertEqual(mail.outbox[0].subject,'Contact Form')\n self.assertEqual(mail.outbox[0].body,'I like your site')\n
LiveServerTestCase does basically the same as\nTransactionTestCase with one extra feature: it launches a\nlive Django server in the background on setup, and shuts it down on teardown.\nThis allows the use of automated test clients other than the\nDjango dummy client such as, for example, the Selenium\nclient, to execute a series of functional tests inside a browser and simulate a\nreal user’s actions.
\n
The live server listens on localhost and binds to port 0 which uses a free\nport assigned by the operating system. The server’s URL can be accessed with\nself.live_server_url during the tests.
\n
To demonstrate how to use LiveServerTestCase, let’s write a Selenium test.\nFirst of all, you need to install the selenium package into your Python\npath:
\n
Linux / macOS
Shell
$ python-mpipinstallselenium\n
\n
Windows
Windows
...\\> py -m pip install selenium\n
\n
Then, add a LiveServerTestCase-based test to your app’s tests module\n(for example: myapp/tests.py). For this example, we’ll assume you’re using\nthe staticfiles app and want to have static files served\nduring the execution of your tests similar to what we get at development time\nwith DEBUG=True, i.e. without having to collect them using\ncollectstatic. We’ll use\nthe StaticLiveServerTestCase\nsubclass which provides that functionality. Replace it with\ndjango.test.LiveServerTestCase if you don’t need that.
...\\> manage.py test myapp.tests.MySeleniumTests.test_login\n
\n
This example will automatically open Firefox then go to the login page, enter\nthe credentials and press the «Log in» button. Selenium offers other drivers in\ncase you do not have Firefox installed or wish to use another browser. The\nexample above is just a tiny fraction of what the Selenium client can do; check\nout the full reference for more details.
Every test case in a django.test.*TestCase instance has access to an\ninstance of a Django test client. This client can be accessed as\nself.client. This client is recreated for each test, so you don’t have to\nworry about state (such as cookies) carrying over from one test to another.
\n
This means, instead of instantiating a Client in each test:
If you want to use a different Client class (for example, a subclass\nwith customized behavior), use the client_class class\nattribute:
\n
Code
fromdjango.testimportClient,TestCase\n\nclassMyTestClient(Client):\n # Specialized methods for your environment\n ...\n\nclassMyTest(TestCase):\n client_class=MyTestClient\n\n deftest_my_stuff(self):\n # Here self.client is an instance of MyTestClient...\n call_some_test_code()\n
A test case for a database-backed website isn’t much use if there isn’t any\ndata in the database. Tests are more readable and it’s more maintainable to\ncreate objects using the ORM, for example in TestCase.setUpTestData(),\nhowever, you can also use fixtures.
\n
A fixture is a collection of data that Django knows how to import into a\ndatabase. For example, if your site has user accounts, you might set up a\nfixture of fake user accounts in order to populate your database during tests.
\n
The most straightforward way of creating a fixture is to use the\nmanage.pydumpdata command. This assumes you\nalready have some data in your database. See the dumpdata\ndocumentation for more details.
\n
Once you’ve created a fixture and placed it in a fixtures directory in one\nof your INSTALLED_APPS, you can use it in your unit tests by\nspecifying a fixtures class attribute on your django.test.TestCase\nsubclass:
\n
Code
fromdjango.testimportTestCase\nfrommyapp.modelsimportAnimal\n\nclassAnimalTestCase(TestCase):\n fixtures=['mammals.json','birds']\n\n defsetUp(self):\n # Test definitions as before.\n call_setup_methods()\n\n deftest_fluffy_animals(self):\n # A test that uses the fixtures.\n call_some_test_code()\n
\n
Here’s specifically what will happen:
\n
\n
At the start of each test, before setUp() is run, Django will flush the\ndatabase, returning the database to the state it was in directly after\nmigrate was called.
\n
Then, all the named fixtures are installed. In this example, Django will\ninstall any JSON fixture named mammals, followed by any fixture named\nbirds. See the loaddata documentation for more\ndetails on defining and installing fixtures.
\n
\n
For performance reasons, TestCase loads fixtures once for the entire\ntest class, before setUpTestData(), instead of before each\ntest, and it uses transactions to clean the database before each test. In any case,\nyou can be certain that the outcome of a test will not be affected by another\ntest or by the order of test execution.
\n
By default, fixtures are only loaded into the default database. If you are\nusing multiple databases and set TransactionTestCase.databases,\nfixtures will be loaded into all specified databases.
If your application provides views, you may want to include tests that use the\ntest client to exercise those views. However, an end user is free to deploy the\nviews in your application at any URL of their choosing. This means that your\ntests can’t rely upon the fact that your views will be available at a\nparticular URL. Decorate your test class or test method with\n@override_settings(ROOT_URLCONF=...) for URLconf configuration.
Django sets up a test database corresponding to every database that is\ndefined in the DATABASES definition in your settings and referred to\nby at least one test through databases.
\n
However, a big part of the time taken to run a Django TestCase is consumed\nby the call to flush that ensures that you have a clean database at the\nstart of each test run. If you have multiple databases, multiple flushes are\nrequired (one for each database), which can be a time consuming activity –\nespecially if your tests don’t need to test multi-database activity.
\n
As an optimization, Django only flushes the default database at\nthe start of each test run. If your setup contains multiple databases,\nand you have a test that requires every database to be clean, you can\nuse the databases attribute on the test suite to request extra databases\nto be flushed.
This test case will flush the default and other test databases before\nrunning test_index_page_view. You can also use '__all__' to specify\nthat all of the test databases must be flushed.
\n
The databases flag also controls which databases the\nTransactionTestCase.fixtures are loaded into. By default, fixtures are\nonly loaded into the default database.
\n
Queries against databases not in databases will give assertion errors to\nprevent state leaking between tests.
By default, only the default database will be wrapped in a transaction\nduring a TestCase’s execution and attempts to query other databases will\nresult in assertion errors to prevent state leaking between tests.
\n
Use the databases class attribute on the test class to request transaction\nwrapping against non-default databases.
This test will only allow queries against the other database. Just like for\nSimpleTestCase.databases and TransactionTestCase.databases, the\n'__all__' constant can be used to specify that the test should allow\nqueries to all databases.
For testing purposes it’s often useful to change a setting temporarily and\nrevert to the original value after running the testing code. For this use case\nDjango provides a standard Python context manager (see PEP 343) called\nsettings(), which can be used like this:
\n
Code
fromdjango.testimportTestCase\n\nclassLoginTestCase(TestCase):\n\n deftest_login(self):\n\n # First check for the default behavior\n response=self.client.get('/sekrit/')\n self.assertRedirects(response,'/accounts/login/?next=/sekrit/')\n\n # Then override the LOGIN_URL setting\n withself.settings(LOGIN_URL='/other/login/'):\n response=self.client.get('/sekrit/')\n self.assertRedirects(response,'/other/login/?next=/sekrit/')\n
\n
This example will override the LOGIN_URL setting for the code\nin the with block and reset its value to the previous state afterward.
It can prove unwieldy to redefine settings that contain a list of values. In\npractice, adding or removing values is often sufficient. Django provides the\nmodify_settings() context manager for easier\nsettings changes:
For each action, you can supply either a list of values or a string. When the\nvalue already exists in the list, append and prepend have no effect;\nneither does remove when the value doesn’t exist.
When overriding settings, make sure to handle the cases in which your app’s\ncode uses a cache or similar feature that retains state even if the setting is\nchanged. Django provides the django.test.signals.setting_changed\nsignal that lets you register callbacks to clean up and otherwise reset state\nwhen settings are changed.
\n
Django itself uses this signal to reset various data:
Registers the models defined within a wrapped context into their own\nisolated apps registry. This functionality is useful\nwhen creating model classes for tests, as the classes will be cleanly\ndeleted afterward, and there is no risk of name collisions.
\n
The app labels which the isolated registry should contain must be passed as\nindividual arguments. You can use isolate_apps() as a decorator or a\ncontext manager. For example:
The decorator form can also be applied to classes.
\n
Two optional keyword arguments can be specified:
\n
\n
attr_name: attribute assigned the isolated registry if used as a\nclass decorator.
\n
kwarg_name: keyword argument passing the isolated registry if used as\na function decorator.
\n
\n
The 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:
As Python’s normal unittest.TestCase class implements assertion methods\nsuch as assertTrue() and\nassertEqual(), Django’s custom TestCase class\nprovides a number of custom assertion methods that are useful for testing web\napplications:
\n
The failure messages given by most of these assertion methods can be customized\nwith the msg_prefix argument. This string will be prefixed to any failure\nmessage generated by the assertion. This allows you to provide additional\ndetails that may help you to identify the location and cause of a failure in\nyour test suite.
\n
\n
\nSimpleTestCase.assertRaisesMessage(expected_exception, expected_message, callable, *args, **kwargs)Link to this definition#
Asserts that execution of callable raises expected_exception and\nthat expected_message is found in the exception’s message. Any other\noutcome is reported as a failure. It’s a simpler version of\nunittest.TestCase.assertRaisesRegex() with the difference that\nexpected_message isn’t treated as a regular expression.
\n
If only the expected_exception and expected_message parameters are\ngiven, returns a context manager so that the code being tested can be\nwritten inline rather than as a function:
\n
Code
withself.assertRaisesMessage(ValueError,'invalid literal for int()'):\n int('a')\n
\n
\n\n
\n
\nSimpleTestCase.assertWarnsMessage(expected_warning, expected_message, callable, *args, **kwargs)Link to this definition#
Asserts that a field on a form raises the provided list of errors.
\n
form is a Form instance. The form must be\nbound but not necessarily\nvalidated (assertFormError() will automatically call full_clean()\non the form).
\n
field is the name of the field on the form to check. To check the form’s\nnon-fielderrors, use\nfield=None.
\n
errors is a list of all the error strings that the field is expected to\nhave. You can also pass a single error string if you only expect one error\nwhich means that errors='errormessage' is the same as\nerrors=['errormessage'].
\n\n\n
\n\n
\n
\nSimpleTestCase.assertFormsetError(formset, form_index, field, errors, msg_prefix='')Link to this definition#
\n
Asserts that the formset raises the provided list of errors when\nrendered.
\n
formset is a Formset instance. The formset must be bound but not\nnecessarily validated (assertFormsetError() will automatically call the\nfull_clean() on the formset).
\n
form_index is the number of the form within the Formset (starting\nfrom 0). Use form_index=None to check the formset’s non-form errors,\ni.e. the errors you get when calling formset.non_form_errors(). In that\ncase you must also use field=None.
\n
field and errors have the same meaning as the parameters to\nassertFormError().
\n\n
\n\n
\n
\nSimpleTestCase.assertContains(response, text, count=None, status_code=200, msg_prefix='', html=False)Link to this definition#
\n
Asserts that a response produced the\ngiven status_code and that text\nappears in its content. If count\nis provided, text must occur exactly count times in the response.
\n
Set html to True to handle text as HTML. The comparison with\nthe response content will be based on HTML semantics instead of\ncharacter-by-character equality. Whitespace is ignored in most cases,\nattribute ordering is not significant. See\nassertHTMLEqual() for more details.
\n
\n\n
\n
\nSimpleTestCase.assertNotContains(response, text, status_code=200, msg_prefix='', html=False)Link to this definition#
Set html to True to handle text as HTML. The comparison with\nthe response content will be based on HTML semantics instead of\ncharacter-by-character equality. Whitespace is ignored in most cases,\nattribute ordering is not significant. See\nassertHTMLEqual() for more details.
\n
\n\n
\n
\nSimpleTestCase.assertTemplateUsed(response, template_name, msg_prefix='', count=None)Link to this definition#
\n
Asserts that the template with the given name was used in rendering the\nresponse.
\n
response must be a response instance returned by the\ntestclient.
\n
template_name should be a string such as 'admin/index.html'.
\n
The count argument is an integer indicating the number of times the\ntemplate should be rendered. Default is None, meaning that the template\nshould be rendered one or more times.
Asserts that two URLs are the same, ignoring the order of query string\nparameters except for parameters with the same name. For example,\n/path/?x=1&y=2 is equal to /path/?y=2&x=1, but\n/path/?a=1&a=2 isn’t equal to /path/?a=2&a=1.
\n
\n\n
\n
\nSimpleTestCase.assertRedirects(response, expected_url, status_code=302, target_status_code=200, msg_prefix='', fetch_redirect_response=True)Link to this definition#
\n
Asserts that the response returned a\nstatus_code redirect status, redirected\nto expected_url (including any GET data), and that the final page\nwas received with target_status_code.
\n
If your request used the follow argument, the expected_url and\ntarget_status_code will be the url and status code for the final\npoint of the redirect chain.
\n
If fetch_redirect_response is False, the final page won’t be\nloaded. Since the test client can’t fetch external URLs, this is\nparticularly useful if expected_url isn’t part of your Django app.
\n
Scheme is handled correctly when making comparisons between two URLs. If\nthere isn’t any scheme specified in the location where we are redirected to,\nthe original request’s scheme is used. If present, the scheme in\nexpected_url is the one used to make the comparisons to.
Asserts that the strings xml1 and xml2 are equal. The\ncomparison is based on XML semantics. Similarly to\nassertHTMLEqual(), the comparison is\nmade on parsed content, hence only semantic differences are considered, not\nsyntax differences. When invalid XML is passed in any parameter, an\nAssertionError is always raised, even if both strings are identical.
\n
XML declaration, document type, processing instructions, and comments are\nignored. Only the root element and its children are compared.
\n
Output in case of error can be customized with the msg argument.
Asserts that the JSON fragments raw and expected_data are equal.\nUsual JSON non-significant whitespace rules apply as the heavyweight is\ndelegated to the json library.
\n
Output in case of error can be customized with the msg argument.
Asserts that the JSON fragments raw and expected_data are not equal.\nSee assertJSONEqual() for further details.
\n
Output in case of error can be customized with the msg argument.
\n
\n\n
\n
\nTransactionTestCase.assertQuerysetEqual(qs, values, transform=None, ordered=True, msg=None)Link to this definition#
\n
Asserts that a queryset qs matches a particular iterable of values\nvalues.
\n
If transform is provided, values is compared to a list produced by\napplying transform to each member of qs.
\n
By default, the comparison is also ordering dependent. If qs doesn’t\nprovide an implicit ordering, you can set the ordered parameter to\nFalse, which turns the comparison into a collections.Counter comparison.\nIf the order is undefined (if the given qs isn’t ordered and the\ncomparison is against more than one ordered value), a ValueError is\nraised.
\n
Output in case of error can be customized with the msg argument.
If you merely want to test the output of your asynchronous views, the standard\ntest client will run them inside their own asynchronous loop without any extra\nwork needed on your part.
\n
However, if you want to write fully-asynchronous tests for a Django project,\nyou will need to take several things into account.
\n
Firstly, your tests must be asyncdef methods on the test class (in order\nto give them an asynchronous context). Django will automatically detect\nany asyncdef tests and wrap them so they run in their own event loop.
\n
If you are testing from an asynchronous function, you must also use the\nasynchronous test client. This is available as django.test.AsyncClient,\nor as self.async_client on any test.
\n
\n
\nclassAsyncClient(enforce_csrf_checks=False, raise_request_exception=True, **defaults)Link to this definition#
\n
\n\n
AsyncClient has the same methods and signatures as the synchronous (normal)\ntest client, with two exceptions:
\n
\n
In the initialization, arbitrary keyword arguments in defaults are added\ndirectly into the ASGI scope.
\n
The follow parameter is not supported.
\n
Headers passed as extra keyword arguments should not have the HTTP_\nprefix required by the synchronous client (see Client.get()). For\nexample, here is how to set an HTTP Accept header:
The asynchronous client can also call synchronous views; it runs through\nDjango’s asynchronous request path, which supports both.\nAny view called through the AsyncClient will get an ASGIRequest object\nfor its request rather than the WSGIRequest that the normal client\ncreates.
If any of your Django views send email using Django’s email\nfunctionality, you probably don’t want to send email each time\nyou run a test using that view. For this reason, Django’s test runner\nautomatically redirects all Django-sent email to a dummy outbox. This lets you\ntest every aspect of sending email – from the number of messages sent to the\ncontents of each message – without actually sending the messages.
\n
The test runner accomplishes this by transparently replacing the normal\nemail backend with a testing backend.\n(Don’t worry – this has no effect on any other email senders outside of\nDjango, such as your machine’s mail server, if you’re running one.)
During test running, each outgoing email is saved in\ndjango.core.mail.outbox. This is a list of all\nEmailMessage instances that have been sent. The\noutbox attribute is a special attribute that is created only when the\nlocmem email backend is used. It doesn’t normally exist as part of the\ndjango.core.mail module and you can’t import it directly. The code below\nshows how to access this attribute correctly.
\n
Here’s an example test that examines django.core.mail.outbox for length\nand contents:
\n
Code
fromdjango.coreimportmail\nfromdjango.testimportTestCase\n\nclassEmailTest(TestCase):\n deftest_send_email(self):\n # Send message.\n mail.send_mail(\n 'Subject here','Here is the message.',\n 'from@example.com',['to@example.com'],\n fail_silently=False,\n )\n\n # Test that one message has been sent.\n self.assertEqual(len(mail.outbox),1)\n\n # Verify that the subject of the first message is correct.\n self.assertEqual(mail.outbox[0].subject,'Subject here')\n
\n
As noted previously, the test outbox is emptied\nat the start of every test in a Django *TestCase. To empty the outbox\nmanually, assign the empty list to mail.outbox:
\n
Code
fromdjango.coreimportmail\n\n# Empty the test outbox\nmail.outbox=[]\n
The unittest library provides the @skipIf and\n@skipUnless decorators to allow you to skip tests\nif you know ahead of time that those tests are going to fail under certain\nconditions.
\n
For example, if your test requires a particular optional library in order to\nsucceed, you could decorate the test case with @skipIf. Then, the test runner will report that the test wasn’t\nexecuted and why, instead of failing the test or omitting the test altogether.
\n
To supplement these test skipping behaviors, Django provides two\nadditional skip decorators. Instead of testing a generic boolean,\nthese decorators check the capabilities of the database, and skip the\ntest if the database doesn’t support a specific named feature.
\n
The decorators use a string identifier to describe database features.\nThis string corresponds to attributes of the database connection\nfeatures class. See\ndjango.db.backends.base.features.BaseDatabaseFeatures class for a full list of database features\nthat can be used as a basis for skipping tests.
Skip the decorated test or TestCase if all of the named database features\nare supported.
\n
For example, the following test will not be executed if the database\nsupports transactions (e.g., it would not run under PostgreSQL, but\nit would under MySQL with MyISAM tables):
\n
Code
classMyTests(TestCase):\n @skipIfDBFeature('supports_transactions')\n deftest_transaction_behavior(self):\n # ... conditional test code\n pass\n
Skip the decorated test or TestCase if any of the named database features\nare not supported.
\n
For example, the following test will only be executed if the database\nsupports transactions (e.g., it would run under PostgreSQL, but not\nunder MySQL with MyISAM tables):
\n
Code
classMyTests(TestCase):\n @skipUnlessDBFeature('supports_transactions')\n deftest_transaction_behavior(self):\n # ... conditional test code\n pass\n
\n","rootId":"testing-tools","toc":[{"title":"The test client","anchor":"the-test-client","children":[{"title":"Overview and a quick example","anchor":"overview-and-a-quick-example","children":[]},{"title":"Making requests","anchor":"making-requests","children":[]},{"title":"Testing responses","anchor":"testing-responses","children":[]},{"title":"Exceptions","anchor":"exceptions","children":[]},{"title":"Persistent state","anchor":"persistent-state","children":[]},{"title":"Setting the language","anchor":"setting-the-language","children":[]},{"title":"Example","anchor":"example","children":[]}]},{"title":"Provided test case classes","anchor":"provided-test-case-classes","children":[{"title":"SimpleTestCase","anchor":"simpletestcase","children":[]},{"title":"TransactionTestCase","anchor":"transactiontestcase","children":[]},{"title":"TestCase","anchor":"testcase","children":[]},{"title":"LiveServerTestCase","anchor":"liveservertestcase","children":[]}]},{"title":"Test cases features","anchor":"test-cases-features","children":[{"title":"Default test client","anchor":"default-test-client","children":[]},{"title":"Customizing the test client","anchor":"customizing-the-test-client","children":[]},{"title":"Fixture loading","anchor":"fixture-loading","children":[]},{"title":"URLconf configuration","anchor":"urlconf-configuration","children":[]},{"title":"Multi-database support","anchor":"multi-database-support","children":[]},{"title":"Overriding settings","anchor":"overriding-settings","children":[]},{"title":"Isolating apps","anchor":"isolating-apps","children":[]},{"title":"Emptying the test outbox","anchor":"emptying-the-test-outbox","children":[]},{"title":"Assertions","anchor":"assertions","children":[]},{"title":"Tagging tests","anchor":"tagging-tests","children":[]}]},{"title":"Testing asynchronous code","anchor":"testing-asynchronous-code","children":[]},{"title":"Email services","anchor":"email-services","children":[]},{"title":"Management Commands","anchor":"management-commands","children":[]},{"title":"Skipping tests","anchor":"skipping-tests","children":[]}],"breadcrumbs":[{"docname":"topics/index","title":"Using Django","url":"/it/4.1/topics/"},{"docname":"topics/testing/index","title":"Testing in Django","url":"/it/4.1/topics/testing/"}],"prev":{"docname":"topics/testing/overview","title":"Writing and running tests","url":"/it/4.1/topics/testing/overview/"},"next":{"docname":"topics/testing/advanced","title":"Advanced testing topics","url":"/it/4.1/topics/testing/advanced/"},"formats":{"html":"/it/4.1/topics/testing/tools/","markdown":"/it/4.1/topics/testing/tools.md","json":"/it/4.1/topics/testing/tools.json"},"source":"https://github.com/django/django/blob/stable/4.1.x/docs/topics/testing/tools.txt","official":"https://docs.djangoproject.com/it/4.1/topics/testing/tools/","inVersions":["6.1","6.0","5.2","5.1","5.0","4.2","4.1","4.0","3.2"],"inLocales":["en","zh-hans","fr","ja","id","it","pt-br","ko","es","el","pl"]}
![\"Hierarchy](\"../../../../../../_images/django_unittest_classes_hierarchy.svg\")
\n\n