{"title":"テストツール","version":"4.1","locale":"ja","docname":"topics/testing/tools","url":"/ja/4.1/topics/testing/tools/","canonical":"https://djangodocs.dev/ja/4.1/topics/testing/tools/","summary":"Django は、テストを書くのに便利なツールをいくつか提供しています。 テストクライアント Link to this heading # The test client is a Python class that acts as a dummy web browser, allowing you to test your…","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
テストクライアントでは、次のようなことができます。
\n
\n
ある URL に対する GET および POST リクエストのシミュレートと、その結果の観察。低レベルの HTTP (レスポンスのヘッダーやステータスコードなど) から、ページのコンテンツまで、あらゆるレスポンスの内容を調査することができます。
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.
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.
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.
\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.
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().
...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
GET の引数がすでに URL エンコードされた形式である場合は、data 引数の代わりにエンコード済みの文字列を使うことができます。たとえば、先ほどの GET リクエストは次のようにも書けます。
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.
たとえば <selectmultiple> の複数の選択を指定する場合のように、特定のキーに対して複数の値を送信したいときは、必要なキーに対する値をリストまたはタプルとして与えます。たとえば、 data に次の値を与えれば、3つの選択した値を choice という名前のフィールドに対して送信できます。
\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:
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.
# 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
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 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.
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
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
例:
\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
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.
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
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":"テストクライアント","anchor":"the-test-client","children":[{"title":"概要と簡単な例","anchor":"overview-and-a-quick-example","children":[]},{"title":"リクエストの作成","anchor":"making-requests","children":[]},{"title":"レスポンスのテスト","anchor":"testing-responses","children":[]},{"title":"例外","anchor":"exceptions","children":[]},{"title":"Persistent state","anchor":"persistent-state","children":[]},{"title":"言語の設定","anchor":"setting-the-language","children":[]},{"title":"カスタマイズ例","anchor":"example","children":[]}]},{"title":"提供されるテストケースのクラス","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":"テストケースの機能","anchor":"test-cases-features","children":[{"title":"デフォルトのテストクライアント","anchor":"default-test-client","children":[]},{"title":"テストクライアントをカスタムする","anchor":"customizing-the-test-client","children":[]},{"title":"フィクスチャーのロード","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":"管理コマンド","anchor":"management-commands","children":[]},{"title":"Skipping tests","anchor":"skipping-tests","children":[]}],"breadcrumbs":[{"docname":"topics/index","title":"Django を使う","url":"/ja/4.1/topics/"},{"docname":"topics/testing/index","title":"Django におけるテスト","url":"/ja/4.1/topics/testing/"}],"prev":{"docname":"topics/testing/overview","title":"テストを書いて実行する","url":"/ja/4.1/topics/testing/overview/"},"next":{"docname":"topics/testing/advanced","title":"Advanced testing topics","url":"/ja/4.1/topics/testing/advanced/"},"formats":{"html":"/ja/4.1/topics/testing/tools/","markdown":"/ja/4.1/topics/testing/tools.md","json":"/ja/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/ja/4.1/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","zh-hans","fr","ja","id","it","pt-br","ko","es","el","pl"]}
![\"Hierarchy](\"../../../../../../_images/django_unittest_classes_hierarchy.svg\")
\n\n