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 be compared by name, as the functions\n# generated by as_view() won't be equal\nself.assertEqual(response.resolver_match.func.__name__, MyView.as_view().__name__)\n
\n
If the given URL is not found, accessing this attribute will raise a\nResolver404 exception.
\n
\n\n
\n\n
You can also use dictionary syntax on the response object to query the value\nof any settings in the HTTP headers. For example, you could determine the\ncontent type of a response using response['Content-Type'].
If you point the test client at a view that raises an exception, that exception\nwill be visible in the test case. You can then use a standard try ... except\nblock or assertRaises() 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.
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 two attributes that store persistent state information. You\ncan access 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.confimport settings\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
If the middleware isn't enabled, the active language may be set using\ntranslation.override():
\n
Code
fromdjango.utilsimport translation\n\ndeftest_language_using_override(self):\n with translation.override('fr'):\n response =self.client.get('/')\n self.assertEqual(response.content,b"Bienvenue sur mon site.")\n
The following is a simple unit test using the test client:
\n
Code
importunittest\nfromdjango.testimport Client\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
Converting a normal unittest.TestCase to any of the subclasses is\neasy: change the base class of your test from unittest.TestCase to the\nsubclass. All of the standard Python unit test functionality will be available,\nand it will be augmented with some useful additions as described in each\nsection below.
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 allow_database_queries class attribute to True on\nyour test class.
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.testimport TestCase\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
Be careful not to modify any objects created in setUpTestData() in\nyour test methods. Modifications to in-memory objects from setup work done\nat the class level will persist between test methods. If you do need to\nmodify them, you could reload them in the setUp() method with\nrefresh_from_db(), for example.
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
By default the live server listens on localhost and picks the first\navailable port in the 8081-8179 range. Its full URL can be accessed with\nself.live_server_url during the tests.
\n\n
If you'd like to select another address, you may pass a different one using the\ntest --liveserver option, for example:
\n
Shell
$ ./manage.py test --liveserver=localhost:8082\n
\n\n
Another way of changing the default server address is by setting the\nDJANGO_LIVE_TEST_SERVER_ADDRESS environment variable somewhere in your\ncode (for example, in a custom test runner):
In the case where the tests are run by multiple processes in parallel (for\nexample, in the context of several simultaneous continuous integration\nbuilds), the processes will compete for the same address, and therefore your\ntests might randomly fail with an "Address already in use" error. To avoid this\nproblem, you can pass a comma-separated list of ports or ranges of ports (at\nleast as many as the number of potential parallel processes). For example:
\n
Shell
$ ./manage.py test --liveserver=localhost:8082,8090-8100,9000-9200,7041\n
\n
Then, during test execution, each new live test server will try every specified\nport until it finds one that is free and takes it.
\n
To demonstrate how to use LiveServerTestCase, let's write a simple Selenium\ntest. First of all, you need to install the selenium package into your\nPython path:
\n
Shell
$ 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.testimport TestCase, Client\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.py dumpdata 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.testimport TestCase\nfrommyapp.modelsimport Animal\n\nclassAnimalTestCase(TestCase):\n fixtures =['mammals.json','birds']\n\n defsetUp(self):\n # Test definitions as before.\n call_setup_methods()\n\n deftestFluffyAnimals(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 multi_db=True, fixtures will be loaded into all 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\nfile. However, a big part of the time taken to run a Django TestCase\nis consumed by the call to flush that ensures that you have a\nclean database at the start of each test run. If you have multiple\ndatabases, multiple flushes are required (one for each database),\nwhich can be a time consuming activity -- especially if your tests\ndon'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 multi_db attribute on the test suite to request a full\nflush.
This test case will flush all the test databases before running\ntest_index_page_view.
\n
The multi_db flag also affects into which databases the\nTransactionTestCase.fixtures are loaded. By default (when\nmulti_db=False), fixtures are only loaded into the default database.\nIf multi_db=True, fixtures are loaded into 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.testimport TestCase\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 afterwards.
It can prove unwieldy to redefine settings that contain a list of values. In\npractice, adding or removing values is often sufficient. The\nmodify_settings() context manager makes it\neasy:
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.
You can also simulate the absence of a setting by deleting it after settings\nhave been overridden, like this:
\n
Code
@override_settings()\ndeftest_something(self):\n del settings.LOGIN_URL\n ...\n
\n
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:
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
\n
\nSimpleTestCase.assertFieldOutput(fieldclass, valid, invalid, field_args=None, field_kwargs=None, empty_value='')Link to this definition#
\n
Asserts that a form field behaves correctly with various inputs.
\n
\n
パラメータ:
\n
\n
fieldclass -- the class of the field to be tested.
\n
valid -- a dictionary mapping valid inputs to their expected cleaned\nvalues.
\n
invalid -- a dictionary mapping invalid inputs to one or more raised\nerror messages.
\n
field_args -- the args passed to instantiate the field.
\n
field_kwargs -- the kwargs passed to instantiate the field.
\n
empty_value -- the expected clean output for inputs in empty_values.
\n
\n
\n
\n
For example, the following code tests that an EmailField accepts\na@a.com as a valid email address, but rejects aaa with a reasonable\nerror message:
\n
Code
self.assertFieldOutput(EmailField,{'a@a.com':'a@a.com'},{'aaa':['Enter a valid email address.']})\n
\n
\n\n
\n
\nSimpleTestCase.assertFormError(response, form, field, errors, msg_prefix='')Link to this definition#
\n
Asserts that a field on a form raises the provided list of errors when\nrendered on the form.
\n
form is the name the Form instance was given in the template\ncontext.
\n
field is the name of the field on the form to check. If field\nhas a value of None, non-field errors (errors you can access via\nform.non_field_errors()) will\nbe checked.
\n
errors is an error string, or a list of error strings, that are\nexpected as a result of form validation.
\n
\n\n
\n
\nSimpleTestCase.assertFormsetError(response, 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 the name the Formset instance was given in the template\ncontext.
\n
form_index is the number of the form within the Formset. If\nform_index has a value of None, non-form errors (errors you can\naccess via formset.non_form_errors()) will be checked.
\n
field is the name of the field on the form to check. If field\nhas a value of None, non-field errors (errors you can access via\nform.non_field_errors()) will\nbe checked.
\n
errors is an error string, or a list of error strings, that are\nexpected as a result of form validation.
\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 instance produced the given status_code and\nthat text appears in the content of the response. If count is\nprovided, 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#
\n
Asserts that a Response instance produced the given status_code and\nthat text does not appear in the content of 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.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
The name is 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.
\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 status_code redirect status,\nredirected to expected_url (including any GET data), and that the\nfinal page was 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 string are identical.
\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=repr, ordered=True, msg=None)Link to this definition#
\n
Asserts that a queryset qs returns a particular list of values values.
\n
The comparison of the contents of qs and values is performed using\nthe function transform; by default, this means that the repr() of\neach value is compared. Any other callable can be used if repr() doesn't\nprovide a unique or helpful comparison.
\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 values), a ValueError is\nraised.
\n
Output in case of error can be customized with the msg argument.
Asserts that when func is called with *args and **kwargs that\nnum database queries are executed.
\n
If a "using" key is present in kwargs it is used as the database\nalias for which to check the number of queries. If you wish to call a\nfunction with a using parameter you can do it by wrapping the call with\na lambda to add an extra parameter:
Then you can choose which tests to run. For example, to run only fast tests:
\n
Shell
$ ./manage.py test --tag=fast\n
\n
Or to run fast tests and the core one (even though it's slow):
\n
Shell
$ ./manage.py test --tag=fast --tag=core\n
\n
You can also exclude tests by tag. To run core tests if they are not slow:
\n
Shell
$ ./manage.py test --tag=core --exclude-tag=slow\n
\n
test --exclude-tag has precedence over test --tag, so if a\ntest has two tags and you select one of them and exclude the other, the test\nwon't be run.
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 simple list of all\nEmailMessage instances that have been sent.\nThe outbox attribute is a special attribute that is created only when\nthe locmem 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\nbelow shows 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.coreimport mail\nfromdjango.testimport TestCase\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.coreimport mail\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 django.db.backends.BaseDatabaseFeatures\nclass for a full list of database features that can be used as a basis\nfor 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":"テストクライアント","anchor":"the-test-client","children":[{"title":"概要と簡単な例","anchor":"overview-and-a-quick-example","children":[]},{"title":"リクエストの作成","anchor":"making-requests","children":[]},{"title":"Testing responses","anchor":"testing-responses","children":[]},{"title":"例外","anchor":"exceptions","children":[]},{"title":"Persistent state","anchor":"persistent-state","children":[]},{"title":"Setting the language","anchor":"setting-the-language","children":[]},{"title":"カスタマイズ例","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":"Emptying the test outbox","anchor":"emptying-the-test-outbox","children":[]},{"title":"Assertions","anchor":"assertions","children":[]},{"title":"Tagging tests","anchor":"tagging-tests","children":[]}]},{"title":"Email services","anchor":"email-services","children":[]},{"title":"管理コマンド","anchor":"management-commands","children":[]},{"title":"Skipping tests","anchor":"skipping-tests","children":[]}],"breadcrumbs":[{"docname":"topics/index","title":"Django を使う","url":"/ja/1.10/topics/"},{"docname":"topics/testing/index","title":"Django におけるテスト","url":"/ja/1.10/topics/testing/"}],"prev":{"docname":"topics/testing/overview","title":"テストを書いて実行する","url":"/ja/1.10/topics/testing/overview/"},"next":{"docname":"topics/testing/advanced","title":"Advanced testing topics","url":"/ja/1.10/topics/testing/advanced/"},"formats":{"html":"/ja/1.10/topics/testing/tools/","markdown":"/ja/1.10/topics/testing/tools.md","json":"/ja/1.10/topics/testing/tools.json"},"source":"https://github.com/django/django/blob/stable/1.10.x/docs/topics/testing/tools.txt","official":"https://docs.djangoproject.com/ja/1.10/topics/testing/tools/","inVersions":["6.1","6.0","5.2","5.1","5.0","4.2","4.1","4.0","3.2","3.1","3.0","2.2","2.1","2.0","1.11","1.10","1.9"],"inLocales":["en","fr","ja","id","pt-br","es","el","pl"]}
![\"Hierarchy](\"../../../../../../_images/django_unittest_classes_hierarchy.svg\")
\n\n