\n测试客户端是一个 Python 类，它充当虚拟的网络浏览器，允许你以编程方式测试你的视图并与你的基于 Django 的应用程序进行交互。
\n你可以使用测试客户端执行以下操作：
\n\n模拟 URL 上的 GET 和 POST 请求并观察响应——从低级 HTTP（结果头和状态码）到页面内容，应有尽有。
查看重定向链（如果有的话），并检查每个步骤的 URL 和状态码。
测试给定的请求是否由给定的包含某些值以及模板上下文的 Django 模板渲染。
\n请注意，测试客户端并不是要取代 Selenium 或其他“浏览器内”框架。Django 的测试客户端有不同的侧重点。简而言之：
\n\n使用 Django 的测试客户端来确定要渲染的模板正确，并且模板已传递了正确的上下文数据。
使用 RequestFactory
使用像 Selenium 这样的浏览器框架来测试 渲染的 HTML 和网页的 行为 ，即 JavaScript 功能。Django 还为这些框架提供了特殊的支持；请参阅 LiveServerTestCase
\n一个全面的测试套件应该使用所有这些测试类型的组合。
\n\n\n要使用测试客户端，请实例化 django.test.Client
\nPython console Copy
>>> from django.test import Client \n>>> c = Client () \n>>> response = c . post ( "/login/" , { "username" : "john" , "password" : "smith" }) \n>>> response . status_code \n200 \n>>> response = c . get ( "/customer/details/" ) \n>>> response . content \nb'<!DOCTYPE html...' \n如本例所示，你可以从 Python 交互式解释器的会话中实例化 Client
\n请注意测试客户端如何工作的一些重要事项：
\n\n测试客户端 不需要 web 服务器正在运行。事实上，它甚至可以在没有任何 web 服务器运行的情况下正常工作！这是因为它避免了 HTTP 的开销，直接与 Django 框架交互。这有助于快速运行单元测试。
在检索页面时，请记住指定 URL 的 路径 ，而不是整个域名。例如，这是正确的：
\nPython console Copy
>>> c . get ( "/login/" ) \n这是不正确的：
\nPython console Copy
>>> c . get ( "https://www.example.com/login/" ) \n测试客户端无法获取不由你的 Django 项目提供支持的网页。如果你需要获取其他网页，使用 Python 标准库模块如 urllib
\n为了解析 URL，测试客户端使用你的 ROOT_URLCONF
虽然上面的例子可以在 Python 交互式解释器中工作，但是测试客户端的一些功能，尤其是与模板相关的功能，只有在 测试运行时 才可以使用。
\n原因是 Django 的测试运行器为了确定哪个模板被给定的视图加载，执行了一点黑魔法。这个黑魔法（本质上是内存中 Django 模板系统的补丁）只发生在测试运行期间。
\n默认情况下，测试客户端将禁用站点执行的任何 CSRF 检查。
\n如果出于某种原因，你 想要 测试客户端执行 CSRF 检查，你可以创建一个强制执行 CSRF 检查的测试客户端实例。要做到这一点，构建客户端时传入 enforce_csrf_checks
\nPython console Copy
>>> from django.test import Client \n>>> csrf_client = Client ( enforce_csrf_checks = True ) \n \n \n\n\n使用 django.test.Client
\n\n\nclass Client ( enforce_csrf_checks = False raise_request_exception = True json_encoder = DjangoJSONEncoder * headers = None query_params = None ** defaults ) Link to this definition # \n一个用于测试的 HTTP 客户端。接受多个参数，可以自定义其行为。
\nheaders User-Agent
\nCode Copy
client = Client ( headers = { "user-agent" : "curl/7.79.1" }) \nquery_params
\n在 **defaults environ 变量
\nCode Copy
client = Client ( SCRIPT_NAME = "/app/" ) \n传递给 get() post() headers query_params extra
\nenforce_csrf_checks
\nraise_request_exception True
\njson_encoder post()
\n\nChanged in Django 5.1
增加了 query_params
\n \n一旦有了 Client
\n\n\nget ( path data = None follow = False secure = False * headers = None query_params = None ** extra ) Link to this definition # \n对提供的 path Response
\nquery_params
\nPython console Copy
>>> c = Client () \n>>> c . get ( "/customers/details/" , query_params = { "name" : "fred" , "age" : 7 }) \n...将导致等同于以下 GET 请求的评估：
\nText Copy
/customers/details/?name=fred&age=7\n也可以将这些参数传递给 data query_params
\nheaders
\nPython console Copy
>>> c = Client () \n>>> c . get ( \n... "/customers/details/" , \n... query_params = { "name" : "fred" , "age" : 7 }, \n... headers = { "accept" : "application/json" }, \n... ) \n......会将 HTTP 头 HTTP_ACCEPT django.http.HttpRequest.accepts()
\n任意关键字参数设置了 WSGI environ 变量
\nPython console Copy
>>> c = Client () \n>>> c . get ( "/" , SCRIPT_NAME = "/app/" ) \n如果你已经有了 URL 编码形式的 GET 参数，你可以使用该编码而不是使用 data 参数。例如，之前的 GET 请求也可以这样表示：
\nPython console Copy
>>> c = Client () \n>>> c . get ( "/customers/details/?name=fred&age=7" ) \n如果你提供的 URL 同时包含编码的 GET 数据和 query_params data
\n如果将 follow True redirect_chain
\n如果你有一个 URL /redirect_me/ /next/ /final/
\nPython console Copy
>>> response = c . get ( "/redirect_me/" , follow = True ) \n>>> response . redirect_chain \n[('http://testserver/next/', 302), ('http://testserver/final/', 302)] \n如果你把 secure True
\n\nChanged in Django 5.1
增加了 query_params
\n \n \n\n\n\npost ( path data = None content_type = MULTIPART_CONTENT follow = False secure = False * headers = None query_params = None ** extra ) Link to this definition # \n在提供的 path Response
\ndata
\nPython console Copy
>>> c = Client () \n>>> c . post ( "/login/" , { "name" : "fred" , "passwd" : "secret" }) \n...将导致对该 URL 发起 POST 请求的评估：
\n\n...使用以下 POST 数据：
\nText Copy
name=fred&passwd=secret\n如果你提供 application/json 为 content_type data json.dumps() DjangoJSONEncoder Client json_encoder put() patch() delete()
\n如果你要提供任何其他的 content_type text/xml 用于 XML 有效载荷），使用HTTP Content-Type content_type data
\n如果你没有为 content_type data multipart/form-data 的内容类型进行传输。在这种情况下，data
\n要为一个给定的键提交多个值——例如，要指定 <select multiple> data choices
\nCode Copy
{ "choices" : [ "a" , "b" , "d" ]} \n提交文件是一个特殊情况。要提交文件，你只需提供文件字段名称作为键，以及要上传的文件的文件句柄作为值。例如，如果你的表单有字段 name attachment FileField
\nPython console Copy
>>> c = Client () \n>>> with open ( "wishlist.doc" , "rb" ) as fp : \n... c . post ( "/customers/wishes/" , { "name" : "fred" , "attachment" : fp }) \n... \n你也可以提供任何类似文件的对象（例如：StringIO BytesIO ImageField name validate_image_file_extension
\nPython console Copy
>>> from io import BytesIO \n>>> img = BytesIO ( \n... b "GIF89a \\x01\\x00\\x01\\x00\\x00\\x00\\x00 ! \\xf9\\x04\\x01\\x00\\x00\\x00 " \n... b " \\x00 , \\x00\\x00\\x00\\x00\\x01\\x00\\x01\\x00\\x00\\x02\\x01\\x00\\x00 " \n... ) \n>>> img . name = "myimage.gif" \n请注意，如果你想在多次调用 post() post()
\n你还应确保文件的打开方式允许数据被读取。如果你的文件包含二进制数据，如图像，这意味着你需要以 rb
\nheaders query_params extra Client.get()
\n如果你使用 POST 请求的 URL 包含编码的参数，这些参数将在 request.GET 数据中可用。例如，如果你发出请求：
\nPython console Copy
>>> c . post ( \n... "/login/" , { "name" : "fred" , "passwd" : "secret" }, query_params = { "visitor" : "true" } \n... ) \n......处理这个请求的视图可以询问 request.POST 来检索用户名和密码，也可以询问 request.GET 来确定该用户是否是访客。
\n如果将 follow True redirect_chain
\n如果你把 secure True
\n\nChanged in Django 5.1
增加了 query_params
\n \n \n\n\n\nhead ( path data = None follow = False secure = False * headers = None query_params = None ** extra ) Link to this definition # \n对提供的 path Response Client.get() follow secure headers query_params extra
\n\nChanged in Django 5.1
增加了 query_params
\n \n \n\n\n\noptions ( path data = '' content_type = 'application/octet-stream' follow = False secure = False * headers = None query_params = None ** extra ) Link to this definition # \n在提供的 path Response
\n当提供 data Content-Type content_type
\nfollow secure headers query_params extra Client.get()
\n\nChanged in Django 5.1
增加了 query_params
\n \n \n\n\n\nput ( path data = '' content_type = 'application/octet-stream' follow = False secure = False * headers = None query_params = None ** extra ) Link to this definition # \n在提供的 path Response
\n当提供 data Content-Type content_type
\nfollow secure headers query_params extra Client.get()
\n\nChanged in Django 5.1
增加了 query_params
\n \n \n\n\n\npatch ( path data = '' content_type = 'application/octet-stream' follow = False secure = False * headers = None query_params = None ** extra ) Link to this definition # \n在提供的 path Response
\nfollow secure headers query_params extra Client.get()
\n\nChanged in Django 5.1
增加了 query_params
\n \n \n\n\n\ndelete ( path data = '' content_type = 'application/octet-stream' follow = False secure = False * headers = None query_params = None ** extra ) Link to this definition # \n在提供的 path Response
\n当提供 data Content-Type content_type
\nfollow secure headers query_params extra Client.get()
\n\nChanged in Django 5.1
增加了 query_params
\n \n \n\n\n\ntrace ( path follow = False secure = False * headers = None query_params = None ** extra ) Link to this definition # \n在提供的 path Response
\n与其他请求方法不同，data RFC 9110 Section 9.3.8
\nfollow secure headers query_params extra Client.get()
\n\nChanged in Django 5.1
增加了 query_params
\n \n \n\n\n\nlogin ( ** credentials ) Link to this definition # \n \n\n\n\nalogin ( ** credentials ) Link to this definition # \n异步版本 ：alogin()
\n如果你的网站使用了 Django 的 认证系统 login()
\n调用此方法后，测试客户端将拥有通过任何可能构成视图一部分的基于登录的测试所需的所有 cookie 和会话数据。
\ncredentials authentication backend AUTHENTICATION_BACKENDS ModelBackend credentials
\nPython console Copy
>>> 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如果你使用的是不同的认证后端，这个方法可能需要不同的凭证。它需要你的后端 authenticate()
\n如果凭证被接受且登录成功，则 login() True
\n最后，在使用这个方法之前，你需要记得创建用户账户。正如我们上面所解释的，测试运行器是使用测试数据库执行的，默认情况下，数据库中不包含用户。因此，在生产站点上有效的用户账户在测试条件下将无法工作。你需要创建用户作为测试套件的一部分--无论是手动创建（使用 Django 模型 API）还是使用测试夹具。记住，如果你想让你的测试用户有一个密码，你不能直接通过设置密码属性来设置用户的密码——你必须使用 set_password() create_user()
\n \n\n\n\nforce_login ( user backend = None ) Link to this definition # \n \n\n\n\naforce_login ( user backend = None ) Link to this definition # \n异步版本 ：aforce_login()
\n如果你的网站使用了 Django 的 认证系统 force_login() login()
\n与 login() is_active=False
\n用户的 backend backend settings.AUTHENTICATION_BACKENDS[0] login() authenticate()
\n这个方法比 login() 在测试时使用较弱的哈希算法 login()
\n \n\n\n\nlogout ( ) Link to this definition # \n \n\n\n\nalogout ( ) Link to this definition # \n异步版本 ：alogout()
\n如果你的网站使用了 Django 的 认证系统 logout()
\n调用此方法后，测试客户端的所有 cookie 和会话数据都会被清除为默认值。随后的请求将看起来来自一个 AnonymousUser
\n \n\n \n\n \n\n\nget() post() Response Response HttpResponse 不 一样的；测试响应对象有一些额外的数据，对测试代码验证很有用。
\n具体来说，Response
\n\n\nclass Response Link to this definition # \n\n\nclient Link to this definition # \n用于发出请求并得到响应的测试客户端。
\n \n\n\n\ncontent Link to this definition # \n以字节字符串形式的响应主体。 这是视图或任何错误消息所呈现的最终页面内容。
\n \n\n\n\ncontext Link to this definition # \n模板 Context
\n如果渲染的页面使用了多个模板，那么 context Context
\n在渲染过程中使用了多少个模板，你都可以使用 [] name
\nPython console Copy
>>> response = client . get ( "/foo/" ) \n>>> response . context [ "name" ] \n'Arthur' \n \n\n\n\nexc_info Link to this definition # \n一个由三个值组成的元组，它提供了关于在视图期间发生的未处理异常（如果有）的信息。
\n值是（type，value，traceback），与 Python 的 sys.exc_info()
\n\n如果没有发生异常，那么 exc_info None
\n \n\n\n\njson ( ** kwargs ) Link to this definition # \n响应的主体，解析为 JSON。额外的关键字参数将传递给 json.loads()
\nPython console Copy
>>> response = client . get ( "/foo/" ) \n>>> response . json ()[ "name" ] \n'Arthur' \n如果 Content-Type "application/json" ValueError
\n \n\n\n\nrequest Link to this definition # \n激发响应的请求数据。
\n \n\n\n\nwsgi_request Link to this definition # \n由生成响应的测试处理程序生成的 WSGIRequest
\n \n\n\n\nstatus_code Link to this definition # \n整数形式的响应 HTTP 状态。关于定义代码的完整列表，查看 IANA status code registry .
\n \n\n\n\ntemplates Link to this definition # \n用于渲染最终内容的 Template template.name 'admin/index.html'
\n\n \n\n\n\nresolver_match Link to this definition # \n响应的 ResolverMatch func
\nCode Copy
# 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如果找不到给定的 URL，访问这个属性会引发一个 Resolver404
\n \n\n \n\n和普通的响应一样，你也可以通过 HttpResponse.headers response.headers['Content-Type']
\n \n\n\n如果你把测试客户端指向一个会引发异常的视图，并且 Client.raise_request_exception True try ... except assertRaises()
\n测试客户端看不到的异常只有 Http404 PermissionDenied SystemExit SuspiciousOperation response.status_code
\n如果 Client.raise_request_exception False exc_info
\n \n\n\n测试客户端是有状态的。如果一个响应返回一个 cookie，那么这个 cookie 将被存储在测试客户端，并与所有后续的 get() post()
\n不遵循这些 cookie 的过期策略。如果你希望 cookie 过期，请手动删除它或创建一个新的 Client
\n测试客户端具有存储持久状态信息的属性。你可以在测试条件的一部分访问这些属性。
\n\n\nClient. cookies Link to this definition # \n一个 Python SimpleCookie http.cookies
\n \n\n\n\nClient. session Link to this definition # \n一个类似字典的对象，包含会话信息。详细内容请参见 会话文档
\n要修改会话然后保存，必须先将其存储在一个变量中（因为每次访问该属性时都会创建一个新的 SessionStore
\nCode Copy
def test_something ( self ): \n session = self . client . session \n session [ "somekey" ] = "test" \n session . save () \n \n\n\n\nClient. asession ( ) Link to this definition # \n这类似于 session
\n \n\n \n\n\n在测试支持国际化和本地化的应用程序时，你可能想为测试客户端请求设置语言。这样做的方法取决于 LocaleMiddleware
\n如果启用了中间件，可以通过创建一个名为 LANGUAGE_COOKIE_NAME
\nCode Copy
from django.conf import settings \n\n\ndef test_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或在请求中加入 Accept-Language
\nCode Copy
def test_language_using_header ( self ): \n response = self . client . get ( "/" , headers = { "accept-language" : "fr" }) \n self . assertEqual ( response . content , b "Bienvenue sur mon site." ) \n\nNote
\n在使用这些方法时，请确保在每个测试结束时重置活动语言：
\nCode Copy
def tearDown ( self ): \n translation . activate ( settings . LANGUAGE_CODE ) \n \n更多细节请参考 Django 如何发现语言偏好
\n如果中间件没有启用，可以使用 translation.override()
\nCode Copy
from django.utils import translation \n\n\ndef test_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更多细节见 显式设置语言
\n \n\n\n以下是使用测试客户端进行的单元测试：
\nCode Copy
import unittest \nfrom django.test import Client \n\n\nclass SimpleTest ( unittest . TestCase ): \n def setUp ( self ): \n # Every test needs a client. \n self . client = Client () \n\n def test_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 \n \n\n一般的 Python 单元测试类都会扩展一个基类 unittest.TestCase
\n\n\nDjango 单元测试类的层次结构 Link to this image #
\n \n \n你可以将一个普通的 unittest.TestCase unittest.TestCase
\n\n\n\n\nclass SimpleTestCase Link to this definition # \n \n\nunittest.TestCase
\n\n如果你的测试进行任何数据库查询，请使用子类 TransactionTestCase TestCase
\n\n\nSimpleTestCase. databases Link to this definition # \nSimpleTestCase SimpleTestCase databases '__all__'
\n \n\n\nWarning
\nSimpleTestCase TestCase setUpClass() tearDownClass() super
\nCode Copy
class MyTestCase ( TestCase ): \n @classmethod \n def setUpClass ( cls ): \n super () . setUpClass () \n ... \n\n @classmethod \n def tearDownClass ( cls ): \n ... \n super () . tearDownClass () \n如果在 setUpClass() tearDownClass() django.test.TestCase super() setUpClass() unittest.SkipTest super()
\n \n \n\n\n\n\nclass TransactionTestCase Link to this definition # \n \n\nTransactionTestCase SimpleTestCase
\n\nDjango's TestCase TransactionTestCase TestCase select_for_update() TransactionTestCase
\nTransactionTestCase TestCase
\n\n\nWarning
\n在不支持回滚的数据库上运行的 TestCase TransactionTestCase
\n应用 不会看到他们的数据被重新加载 TestCase serialized_rollback = True
\n \n \n\n\n\n\nclass TestCase Link to this definition # \n \n\n这是 Django 中最常用的编写测试的类。它继承自 TransactionTestCase SimpleTestCase SimpleTestCase
\n此类：
\n\n它还提供了另一种方法：
\n\n\nclassmethod TestCase. setUpTestData ( ) Link to this definition # \n上文所述的类级 atomic TestCase setUp()
\n例如：
\nCode Copy
from django.test import TestCase \n\n\nclass MyTests ( TestCase ): \n @classmethod \n def setUpTestData ( cls ): \n # Set up data for the whole TestCase \n cls . foo = Foo . objects . create ( bar = "Test" ) \n ... \n\n def test1 ( self ): \n # Some test using self.foo \n ... \n\n def test2 ( self ): \n # Some other test using self.foo \n ... \n请注意，如果测试是在没有事务支持的数据库上运行（例如，MyISAM 引擎的 MySQL），setUpTestData()
\n在 setUpTestData() copy.deepcopy()
\n \n\n\n\nclassmethod TestCase. captureOnCommitCallbacks ( using = DEFAULT_DB_ALIAS execute = False ) Link to this definition # \n返回一个为给定的数据库连接捕获 transaction.on_commit()
\nusing
\n如果 execute True
\n例如：
\nCode Copy
from django.core import mail \nfrom django.test import TestCase \n\n\nclass ContactTests ( TestCase ): \n def test_post ( self ): \n with self . captureOnCommitCallbacks ( execute = True ) as callbacks : \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 \n\n \n\n\n\nclass LiveServerTestCase Link to this definition # \n \n\nLiveServerTestCase TransactionTestCase Django 虚拟客户端 Selenium 客户端，在浏览器内执行一系列功能测试，并模拟真实用户的操作。
\n实时服务器在 localhost self.live_server_url
\n为了演示如何使用 LiveServerTestCase selenium 包：
\nLinux / macOS
Shell Copy
$ python -m pip install "selenium >= 4.8.0" \n\n
Windows
Windows Copy
...\\> py -m pip install "selenium >= 4.8.0" \n然后，在你的应用程序的测试模块中添加一个基于 LiveServerTestCase myapp/tests.py staticfiles DEBUG=True collectstatic StaticLiveServerTestCase django.test.LiveServerTestCase
\n这个测试的代码可能如下：
\nCode Copy
from django.contrib.staticfiles.testing import StaticLiveServerTestCase \nfrom selenium.webdriver.common.by import By \nfrom selenium.webdriver.firefox.webdriver import WebDriver \n\n\nclass MySeleniumTests ( StaticLiveServerTestCase ): \n fixtures = [ "user-data.json" ] \n\n @classmethod \n def setUpClass ( cls ): \n super () . setUpClass () \n cls . selenium = WebDriver () \n cls . selenium . implicitly_wait ( 10 ) \n\n @classmethod \n def tearDownClass ( cls ): \n cls . selenium . quit () \n super () . tearDownClass () \n\n def test_login ( self ): \n self . selenium . get ( f " { self . live_server_url } /login/" ) \n username_input = self . selenium . find_element ( By . NAME , "username" ) \n username_input . send_keys ( "myuser" ) \n password_input = self . selenium . find_element ( By . NAME , "password" ) \n password_input . send_keys ( "secret" ) \n self . selenium . find_element ( By . XPATH , '//input[@value="Log in"]' ) . click () \n最后，你可以按以下方式进行测试：
\nLinux / macOS
Shell Copy
$ ./manage.py test myapp.tests.MySeleniumTests.test_login\n\n
Windows
Windows Copy
...\\> manage.py test myapp.tests.MySeleniumTests.test_login\n这个例子会自动打开 Firefox，然后进入登录页面，输入凭证并按“登录”按钮。Selenium 提供了其他驱动程序，以防你没有安装 Firefox 或希望使用其他浏览器。上面的例子只是 Selenium 客户端能做的一小部分，更多细节请查看 full reference 。
\n\nNote
\n当使用内存 SQLite 数据库运行测试时，同一个数据库连接将由两个线程并行共享：运行实时服务器的线程和运行测试用例的线程。要防止两个线程通过这个共享连接同时进行数据库查询，因为这有时可能会随机导致测试失败。所以你需要确保两个线程不会同时访问数据库。特别是，这意味着在某些情况下（例如，刚刚点击一个链接或提交一个表单之后），你可能需要检查 Selenium 是否收到了响应，并且在继续执行进一步的测试之前，检查下一个页面是否被加载。例如，让 Selenium 等待直到在响应中找到 <body>
\nCode Copy
def test_login ( self ): \n from selenium.webdriver.support.wait import WebDriverWait \n\n timeout = 2 \n ... \n self . selenium . find_element ( By . XPATH , '//input[@value="Log in"]' ) . click () \n # Wait until the response is received \n WebDriverWait ( self . selenium , timeout ) . until ( \n lambda driver : driver . find_element ( By . TAG_NAME , "body" ) \n ) \n这里的棘手之处在于，实际上并没有真正的 "页面加载"，特别是在现代的 Web 应用程序中，在服务器生成初始文档后，页面会动态生成 HTML。因此，仅仅检查响应中是否存在 <body> Selenium FAQ 和 Selenium documentation 获取更多信息。
\n \n \n \n\n\n\n\n\n\nSimpleTestCase. client Link to this definition # \n \n\ndjango.test.*TestCase self.client
\n这意味着，不必每个测试中实例化一个 Client
\nCode Copy
import unittest \nfrom django.test import Client \n\n\nclass SimpleTest ( unittest . TestCase ): \n def test_details ( self ): \n client = Client () \n response = client . get ( "/customer/details/" ) \n self . assertEqual ( response . status_code , 200 ) \n\n def test_index ( self ): \n client = Client () \n response = client . get ( "/customer/index/" ) \n self . assertEqual ( response . status_code , 200 ) \n......你可以引用 self.client
\nCode Copy
from django.test import TestCase \n\n\nclass SimpleTest ( TestCase ): \n def test_details ( self ): \n response = self . client . get ( "/customer/details/" ) \n self . assertEqual ( response . status_code , 200 ) \n\n def test_index ( self ): \n response = self . client . get ( "/customer/index/" ) \n self . assertEqual ( response . status_code , 200 ) \n \n\n\n\n\nSimpleTestCase. client_class Link to this definition # \n \n\n如果你想使用不同的 Client client_class
\nCode Copy
from django.test import Client , TestCase \n\n\nclass MyTestClient ( Client ): \n # Specialized methods for your environment \n ... \n\n\nclass MyTest ( TestCase ): \n client_class = MyTestClient \n\n def test_my_stuff ( self ): \n # Here self.client is an instance of MyTestClient... \n call_some_test_code () \n \n\n\n\nTransactionTestCase. fixtures Link to this definition # \n \n\n如果数据库中没有任何数据，那么用于数据库支持的网站的测试用例类就没有什么用处。使用 ORM 创建对象更易于阅读和维护，例如在 TestCase.setUpTestData() fixtures
\n辅助工具是 Django 知道如何导入数据库的数据集合。例如，如果你的网站有用户账户，你可能会设置一个假用户账户的辅助工具，以便在测试时填充你的数据库。
\n创建辅助工具的最直接方法是使用 manage.py dumpdata dumpdata 文档
\n一旦你创建了一个辅助工具，并把它放在你的 INSTALLED_APPS fixtures django.test.TestCase fixtures
\nCode Copy
from django.test import TestCase \nfrom myapp.models import Animal \n\n\nclass AnimalTestCase ( TestCase ): \n fixtures = [ "mammals.json" , "birds" ] \n\n def setUp ( self ): \n # Test definitions as before. \n call_setup_methods () \n\n def test_fluffy_animals ( self ): \n # A test that uses the fixtures. \n call_some_test_code () \n具体来说，将发生以下情况：
\n\nDuring setUpClass() mammals birds 辅助工具
\nFor most unit tests using TestCase TransactionTestCase
\n\nAt the end of each test Django will flush the database, returning the\ndatabase to the state it was in directly after migrate
For each subsequent test, the fixtures will be reloaded before setUp()
\nIn any case, you can be certain that the outcome of a test will not be\naffected by another test or by the order of test execution.
\n默认情况下，辅助工具只被加载到 default TransactionTestCase.databases
\n\nChanged in Django 5.2
For TransactionTestCase setUpClass()
\n \n \n\n\n如果你的应用程序提供了视图，你可能希望包含使用测试客户端来行使这些视图的测试。然而，最终用户可以自由地在他们选择的任何 URL 上部署应用程序中的视图。这意味着你的测试不能依赖于你的视图将在特定的 URL 上可用这一事实。用 @override_settings(ROOT_URLCONF=...)
\n \n\n\n\nTransactionTestCase. databases Link to this definition # \n \n\nDjango 设置了一个测试数据库，对应于你设置中的 DATABASES databases
\nHowever, a big part of the time taken to run a Django TestCase flush
\nAs an optimization, Django only flushes the default databases
\n例如：
\nCode Copy
class TestMyViews ( TransactionTestCase ): \n databases = { "default" , "other" } \n\n def test_index_page_view ( self ): \n call_some_test_code () \nThis test case class will flush the default other test_index_page_view '__all__'
\ndatabases TransactionTestCase.fixtures default
\n对不在 databases
\n\n\nTestCase. databases Link to this definition # \n \n\n默认情况下，在 TestCase default
\n在测试类上使用 databases default
\n例如：
\nCode Copy
class OtherDBTests ( TestCase ): \n databases = { "other" } \n\n def test_other_db_query ( self ): ... \n这个测试只允许对 other SimpleTestCase.databases TransactionTestCase.databases '__all__'
\n \n\n\n\nSimpleTestCase. settings ( ) Link to this definition # \n \n\n为了测试的目的，经常需要临时改变一个设置，并在运行测试代码后恢复到原始值。对于这个用例，Django 提供了一个标准的 Python 上下文管理器（见 PEP 343 settings()
\nCode Copy
from django.test import TestCase \n\n\nclass LoginTestCase ( TestCase ): \n def test_login ( self ): \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 with self . settings ( LOGIN_URL = "/other/login/" ): \n response = self . client . get ( "/sekrit/" ) \n self . assertRedirects ( response , "/other/login/?next=/sekrit/" ) \n这个示例将会在 with LOGIN_URL
\n\n\nSimpleTestCase. modify_settings ( ) Link to this definition # \n \n\n重新定义包含一系列值的设置可能会很麻烦。在实践中，添加或删除值通常是足够的。Django 提供了 modify_settings()
\nCode Copy
from django.test import TestCase \n\n\nclass MiddlewareTestCase ( TestCase ): \n def test_cache_middleware ( self ): \n with self . modify_settings ( \n MIDDLEWARE = { \n "append" : "django.middleware.cache.FetchFromCacheMiddleware" , \n "prepend" : "django.middleware.cache.UpdateCacheMiddleware" , \n "remove" : [ \n "django.contrib.sessions.middleware.SessionMiddleware" , \n "django.contrib.auth.middleware.AuthenticationMiddleware" , \n "django.contrib.messages.middleware.MessageMiddleware" , \n ], \n } \n ): \n response = self . client . get ( "/" ) \n # ... \n对于每个操作，你可以提供一个值的列表或一个字符串。当值已经存在于列表中时，append prepend remove
\n\n\noverride_settings ( ** kwargs ) Link to this definition # \n \n\n如果你想覆盖一个测试方法的设置，Django 提供了 override_settings() PEP 318
\nCode Copy
from django.test import TestCase , override_settings \n\n\nclass LoginTestCase ( TestCase ): \n @override_settings ( LOGIN_URL = "/other/login/" ) \n def test_login ( self ): \n response = self . client . get ( "/sekrit/" ) \n self . assertRedirects ( response , "/other/login/?next=/sekrit/" ) \n装饰器也可以应用于 TestCase
\nCode Copy
from django.test import TestCase , override_settings \n\n\n@override_settings ( LOGIN_URL = "/other/login/" ) \nclass LoginTestCase ( TestCase ): \n def test_login ( self ): \n response = self . client . get ( "/sekrit/" ) \n self . assertRedirects ( response , "/other/login/?next=/sekrit/" ) \n\n\nmodify_settings ( * args ** kwargs ) Link to this definition # \n \n\n同样，Django 也提供了 modify_settings()
\nCode Copy
from django.test import TestCase , modify_settings \n\n\nclass MiddlewareTestCase ( TestCase ): \n @modify_settings ( \n MIDDLEWARE = { \n "append" : "django.middleware.cache.FetchFromCacheMiddleware" , \n "prepend" : "django.middleware.cache.UpdateCacheMiddleware" , \n } \n ) \n def test_cache_middleware ( self ): \n response = self . client . get ( "/" ) \n # ... \n此装饰器也可以应用于测试用例类：
\nCode Copy
from django.test import TestCase , modify_settings \n\n\n@modify_settings ( \n MIDDLEWARE = { \n "append" : "django.middleware.cache.FetchFromCacheMiddleware" , \n "prepend" : "django.middleware.cache.UpdateCacheMiddleware" , \n } \n) \nclass MiddlewareTestCase ( TestCase ): \n def test_cache_middleware ( self ): \n response = self . client . get ( "/" ) \n # ... \n\nNote
\n当给定一个类时，这些装饰器直接修改该类并返回它，它们不会创建并返回一个修改后的副本。因此，如果你试图调整上面的例子，将返回值分配给一个不同于 LoginTestCase MiddlewareTestCase modify_settings() override_settings()
\n \n\nWarning
\n配置文件中包含了一些设置，这些设置只有在 Django 内部初始化时才会被使用。如果你用 override_settings override_settings() modify_settings()
\n我们不建议改变 DATABASES CACHES django.contrib.session CACHES
\n最后，避免将你的配置别名为模块级常量，因为 override_settings()
\n \n你也可以在配置被覆盖后，通过删除配置来模拟没有配置，比如这样：
\nCode Copy
@override_settings () \ndef test_something ( self ): \n del settings . LOGIN_URL \n ... \n覆盖配置时，请确保处理你的应用代码使用即使保留配置更改也能保持状态的缓存或类似功能的情况。Django 提供了 django.test.signals.setting_changed
\nDjango 自己也使用这个信号来重置各种数据。
\n\n\n \n\n\n\n\nutils. isolate_apps ( * app_labels attr_name = None kwarg_name = None ) Link to this definition # \n将包装上下文中定义的模型注册到它们自己隔离的 apps
\n应该将应该包含在隔离注册表中的应用程序标签作为单独的参数传递。你可以将 isolate_apps()
\nCode Copy
from django.db import models \nfrom django.test import SimpleTestCase \nfrom django.test.utils import isolate_apps \n\n\nclass MyModelTests ( SimpleTestCase ): \n @isolate_apps ( "app_label" ) \n def test_model_definition ( self ): \n class TestModel ( models . Model ): \n pass \n\n ... \n… 或者：
\nCode Copy
with isolate_apps ( "app_label" ): \n\n class TestModel ( models . Model ): \n pass \n\n ... \n装饰器形式也可以应用于类。
\n可以指定两个可选的关键字参数：
\n\n临时的 Apps attr_name
\nCode Copy
@isolate_apps ( "app_label" , attr_name = "apps" ) \nclass TestModelDefinition ( SimpleTestCase ): \n def test_model_definition ( self ): \n class TestModel ( models . Model ): \n pass \n\n self . assertIs ( self . apps . get_model ( "app_label" , "TestModel" ), TestModel ) \n… 或者，当作为方法装饰器使用时，可以使用 kwarg_name
\nCode Copy
class TestModelDefinition ( SimpleTestCase ): \n @isolate_apps ( "app_label" , kwarg_name = "apps" ) \n def test_model_definition ( self , apps ): \n class TestModel ( models . Model ): \n pass \n\n self . assertIs ( apps . get_model ( "app_label" , "TestModel" ), TestModel ) \n \n\n \n\n如果你使用任何 Django 的自定义 TestCase
\n关于测试期间电子邮件服务的更多细节，请参见下面的 Email services 。
\n \n\n由于 Python 的普通 unittest.TestCase assertTrue() assertEqual() TestCase
\n大多数这些断言方法给出的失败信息可以用 msg_prefix
\n\n\nSimpleTestCase. assertRaisesMessage ( expected_exception expected_message callable * args ** kwargs ) Link to this definition # \n\nSimpleTestCase. assertRaisesMessage ( expected_exception expected_message ) \n断言执行 callable expected_exception expected_message unittest.TestCase.assertRaisesRegex() expected_message
\n如果只给了 expected_exception expected_message
\nCode Copy
with self . assertRaisesMessage ( ValueError , "invalid literal for int()" ): \n int ( "a" ) \n \n\n\n\nSimpleTestCase. assertWarnsMessage ( expected_warning expected_message callable * args ** kwargs ) Link to this definition # \n\nSimpleTestCase. assertWarnsMessage ( expected_warning expected_message ) \n类似于 SimpleTestCase.assertRaisesMessage() assertWarnsRegex() assertRaisesRegex()
\n \n\n\n\nSimpleTestCase. assertFieldOutput ( fieldclass valid invalid field_args = None field_kwargs = None empty_value = '' ) Link to this definition # \n断言表单字段在不同的输入情况下表现正确。
\n\n参数: \n\nfieldclass -- 待测试字段的类。
valid -- 一个字典，将有效输入映射到它们的预期干净值。
invalid -- 一个字典，将无效输入映射到一个或多个引发的错误信息
field_args -- 传递给实例化字段的 args。
field_kwargs -- 传递给实例化字段的 kwargs。
empty_value -- empty_values
\n \n例如，以下代码测试 EmailField a@a.com aaa
\nCode Copy
self . assertFieldOutput ( \n EmailField , { "a@a.com" : "a@a.com" }, { "aaa" : [ "Enter a valid email address." ]} \n) \n \n\n\n\nSimpleTestCase. assertFormError ( form field errors msg_prefix = '' ) Link to this definition # \n断言表单上的字段引发了提供的错误列表。
\nform Form 已绑定 assertFormError() full_clean()
\nfield 非字段错误 field=None
\nerrors errors='错误消息' errors=['错误消息']
\n \n\n\n\nSimpleTestCase. assertFormSetError ( formset form_index field errors msg_prefix = '' ) Link to this definition # \n断言 formset
\nformset FormSet assertFormSetError() full_clean()
\nform_index FormSet form_index=None formset.non_form_errors() field=None
\nfield errors assertFormError()
\n \n\n\n\nSimpleTestCase. assertContains ( response text count = None status_code = 200 msg_prefix = '' html = False ) Link to this definition # \n断言一个生成的 response status_code text content count text count
\n将 html True text assertHTMLEqual()
\n\nChanged in Django 5.1
在旧版本中，错误消息不包含响应内容。
\n \n \n\n\n\nSimpleTestCase. assertNotContains ( response text status_code = 200 msg_prefix = '' html = False ) Link to this definition # \n断言一个生成的 response status_code text 不 出现在它的 content
\n将 html True text assertHTMLEqual()
\n\nChanged in Django 5.1
在旧版本中，错误消息不包含响应内容。
\n \n \n\n\n\nSimpleTestCase. assertTemplateUsed ( response template_name msg_prefix = '' count = None ) Link to this definition # \n断言给定名称的模板被用于渲染响应。
\nresponse test client
\ntemplate_name``应当是一个字符串，如 ``
\ncount None
\n你可以把它作为一个上下文管理器，比如：
\nCode Copy
with self . assertTemplateUsed ( "index.html" ): \n render_to_string ( "index.html" ) \nwith self . assertTemplateUsed ( template_name = "index.html" ): \n render_to_string ( "index.html" ) \n \n\n\n\nSimpleTestCase. assertTemplateNotUsed ( response template_name msg_prefix = '' ) Link to this definition # \n断言给定名称的模板在渲染响应时 没有 被使用。
\n你可以用 assertTemplateUsed()
\n \n\n\n\nSimpleTestCase. assertURLEqual ( url1 url2 msg_prefix = '' ) Link to this definition # \n断言两个 URL 是相同的，忽略查询字符串参数的顺序，但同名参数除外。例如，/path/?x=1&y=2 /path/?y=2&x=1 /path/?a=1&a=2 /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断言返回的 response status_code expected_url GET target_status_code
\n如果你的请求使用了 follow expected_url target_status_code
\n如果 fetch_redirect_response False expected_url
\n在两个 URL 之间进行比较时，可以正确处理协议。如果在我们被重定向到的位置没有指定任何协议，则使用原始请求的协议。如果存在，expected_url
\n \n\n\n\nSimpleTestCase. assertHTMLEqual ( html1 html2 msg = None ) Link to this definition # \n断言字符串 html1 html2
\n\n下面的例子是有效的测试，并且没有引起任何 AssertionError
\nCode Copy
self . assertHTMLEqual ( \n "<p>Hello <b>'world'!</p>" , \n """<p> \n Hello <b>'world'! </b> \n </p>""" , \n) \nself . assertHTMLEqual ( \n '<input type="checkbox" checked="checked" id="id_accept_terms" />' , \n '<input id="id_accept_terms" type="checkbox" checked>' , \n) \nhtml1 html2 AssertionError
\n错误时的输出可以用 msg
\n \n\n\n\nSimpleTestCase. assertHTMLNotEqual ( html1 html2 msg = None ) Link to this definition # \n断言字符串 html1 html2 不 相等。比较是基于 HTML 语义的。详见 assertHTMLEqual()
\nhtml1 html2 AssertionError
\n错误时的输出可以用 msg
\n \n\n\n\nSimpleTestCase. assertXMLEqual ( xml1 xml2 msg = None ) Link to this definition # \n断言字符串 xml1 xml2 assertHTMLEqual() AssertionError
\n忽略 XML 声明、文档类型、处理指令和注释。只有根元素和它的子元素被比较。
\n错误时的输出可以用 msg
\n \n\n\n\nSimpleTestCase. assertXMLNotEqual ( xml1 xml2 msg = None ) Link to this definition # \n断言字符串 xml1 xml2 不 相等。比较是基于 XML 语义的，参见 assertXMLEqual()
\n错误时的输出可以用 msg
\n \n\n\n\nSimpleTestCase. assertInHTML ( needle haystack count = None msg_prefix = '' ) Link to this definition # \n断言 HTML 片段 needle haystack
\n如果指定了 count needle
\n在大多数情况下，空白是被忽略的，属性排序并不重要。参见 assertHTMLEqual()
\n\nChanged in Django 5.1
在旧版本中，错误消息不包含 haystack
\n \n \n\n\n\nSimpleTestCase. assertNotInHTML ( needle haystack msg_prefix = '' ) Link to this definition # \n\n断言 HTML 片段 needle 不 包含在 haystack
\n在大多数情况下，空白是被忽略的，属性排序并不重要。参见 assertHTMLEqual()
\n \n\n\n\nSimpleTestCase. assertJSONEqual ( raw expected_data msg = None ) Link to this definition # \n断言 JSON 片段 raw expected_data json
\n错误时的输出可以用 msg
\n \n\n\n\nSimpleTestCase. assertJSONNotEqual ( raw expected_data msg = None ) Link to this definition # \n断言 JSON 片段 raw expected_data 不 相等。详见 assertJSONEqual()
\n错误时的输出可以用 msg
\n \n\n\n\nTransactionTestCase. assertQuerySetEqual ( qs values transform = None ordered = True msg = None ) Link to this definition # \n断言一个查询集 qs values
\n如果提供了 transform values transform qs
\n默认情况下，比较也是依赖于顺序的。如果 qs ordered False collections.Counter qs ValueError
\n错误时的输出可以用 msg
\n \n\n\n\nTransactionTestCase. assertNumQueries ( num func * args ** kwargs ) Link to this definition # \n断言当 func *args **kwargs num
\n如果 kwargs "using"
\nCode Copy
self . assertNumQueries ( 7 , my_function , using = "non_default_db" ) \n如果你想调用一个带有 using lambda
\nCode Copy
self . assertNumQueries ( 7 , lambda : my_function ( using = 7 )) \n你也可以用它作为上下文管理器:
\nCode Copy
with self . assertNumQueries ( 2 ): \n Person . objects . create ( name = "Aaron" ) \n Person . objects . create ( name = "Daniel" ) \n \n\n \n\n你可以给你的测试打上标签，这样你就可以轻松地运行一个特定的子集。例如，你可以标记快速或慢速测试：
\nCode Copy
from django.test import tag \n\n\nclass SampleTestCase ( TestCase ): \n @tag ( "fast" ) \n def test_fast ( self ): ... \n\n @tag ( "slow" ) \n def test_slow ( self ): ... \n\n @tag ( "slow" , "core" ) \n def test_slow_but_core ( self ): ... \n你还可以给一个测试用例类打上标签：
\nCode Copy
@tag ( "slow" , "core" ) \nclass SampleTestCase ( TestCase ): ... \n子类从超类继承标签，方法从其类继承标签。如：
\nCode Copy
@tag ( "foo" ) \nclass SampleTestCaseChild ( SampleTestCase ): \n @tag ( "bar" ) \n def test ( self ): ... \nSampleTestCaseChild.test 'slow' 'core' 'bar' 'foo'
\n然后你可以选择要运行的测试。例如，只运行快速测试：
\nLinux / macOS
Shell Copy
$ ./manage.py test --tag= fast\n\n
Windows
Windows Copy
...\\> manage.py test --tag=fast\n或者运行快速测试和核心测试（即使它很慢）：
\nLinux / macOS
Shell Copy
$ ./manage.py test --tag= fast --tag= core\n\n
Windows
Windows Copy
...\\> manage.py test --tag=fast --tag=core\n你也可以通过标签来排除测试。如果要运行不慢的核心测试：
\nLinux / macOS
Shell Copy
$ ./manage.py test --tag= core --exclude-tag= slow\n\n
Windows
Windows Copy
...\\> manage.py test --tag=core --exclude-tag=slow\ntest --exclud-tag test --tag
\n \n \n\n如果你只是想测试异步视图的输出，标准测试客户端将在自己的异步循环中运行它们，而不需要你做任何额外的工作。
\n但是，如果你想为 Django 项目编写完全异步的测试，你需要考虑到几个问题。
\n首先，你的测试必须是测试类上的 async def async def
\n如果你从一个异步函数进行测试，你也必须使用异步测试客户端。这在任何测试中都可以作为 django.test.AsyncClient self.async_client
\n\n\nclass AsyncClient ( enforce_csrf_checks = False raise_request_exception = True * headers = None query_params = None ** defaults ) Link to this definition # \n \n\nAsyncClient
\n\n\nChanged in Django 5.1
增加了 query_params
\n \n使用 AsyncClient
\nCode Copy
async def test_my_thing ( self ): \n response = await self . async_client . get ( "/some-url/" ) \n self . assertEqual ( response . status_code , 200 ) \n异步客户端也可以调用同步视图；它通过 Django 的 异步请求路径 AsyncClient ASGIRequest request WSGIRequest
\n\nWarning
\n如果你使用的是测试装饰器，它们必须是异步兼容的，以确保它们正确工作。Django 内置的装饰器会正常工作，但第三方的装饰器可能会出现无法执行的情况（它们会“包装”执行流程中错误的部分，而不是你的测试）。
\n如果你需要使用这些装饰器，那么你应该用 async_to_sync()
\nCode Copy
from asgiref.sync import async_to_sync \nfrom django.test import TestCase \n\n\nclass MyTests ( TestCase ): \n @mock . patch ( ... ) \n @async_to_sync \n async def test_my_thing ( self ): ... \n \n \n\n如果你的任何 Django 视图使用 Django 的邮件功能
\n测试运行器通过透明的将正常的邮件后端替换为测试后端来实现。（别担心——这对 Django 之外的其他邮件发送器没有影响，比如你机器的邮件服务器，如果你正在运行一个的话。）
\n\n\ndjango.core.mail. outbox Link to this definition # \n \n\n在测试运行过程中，每一封发出的邮件都会保存在 django.core.mail.outbox EmailMessage outbox locmem django.core.mail
\n下面是一个检查 django.core.mail.outbox
\nCode Copy
from django.core import mail \nfrom django.test import TestCase \n\n\nclass EmailTest ( TestCase ): \n def test_send_email ( self ): \n # Send message. \n mail . send_mail ( \n "Subject here" , \n "Here is the message." , \n "from@example.com" , \n [ "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正如 之前 *TestCase mail.outbox
\nCode Copy
from django.core import mail \n\n# Empty the test outbox \nmail . outbox = [] \n \n\nunittest 库提供了 @skipIf @skipUnless
\n例如，如果你的测试需要一个特定的可选库才能成功，你可以用 @skipIf
\n为了补充这些测试跳过行为，Django 提供了两个额外的跳过装饰器。这些装饰器不是测试一个通用的布尔值，而是检查数据库的能力，如果数据库不支持一个特定的命名特性，则跳过测试。
\n装饰器使用一个字符串标识符来描述数据库特征。这个字符串对应于数据库连接特征类的属性。参见 django.db.backends.base.features.BaseDatabaseFeatures 类 以获得可作为跳过测试基础的数据库特征的完整列表。
\n\n\nskipIfDBFeature ( * feature_name_strings ) Link to this definition # \n \n\n如果支持某个命名的数据库功能，则跳过装饰测试或 TestCase
\n例如，如果数据库支持事务，下面的测试将不会被执行（例如，在PostgreSQL 下，它将 不 会运行，但在 MySQL 的 MyISAM 表下却可以）：
\nCode Copy
class MyTests ( TestCase ): \n @skipIfDBFeature ( "supports_transactions" ) \n def test_transaction_behavior ( self ): \n # ... conditional test code \n pass \n\n\nskipUnlessDBFeature ( * feature_name_strings ) Link to this definition # \n \n\n如果 不 支持某个命名的数据库功能，则跳过装饰测试或 TestCase
\n例如，接下来的测试仅在支持事务的数据库下执行(如：可以是PostgreSQL，但不可以是使用MyISAM数据库引擎的MySQL):
\nCode Copy
class MyTests ( TestCase ): \n @skipUnlessDBFeature ( "supports_transactions" ) \n def test_transaction_behavior ( self ): \n # ... conditional test code \n pass \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":"持久状态","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 配置","anchor":"urlconf-configuration","children":[]},{"title":"多数据库支持","anchor":"multi-database-support","children":[]},{"title":"覆盖配置","anchor":"overriding-settings","children":[]},{"title":"隔离应用程序","anchor":"isolating-apps","children":[]},{"title":"清空测试发件箱","anchor":"emptying-the-test-outbox","children":[]},{"title":"断言","anchor":"assertions","children":[]},{"title":"标记测试","anchor":"tagging-tests","children":[]}]},{"title":"测试异步代码","anchor":"testing-asynchronous-code","children":[]},{"title":"邮件服务","anchor":"email-services","children":[]},{"title":"管理命令","anchor":"management-commands","children":[]},{"title":"忽略测试","anchor":"skipping-tests","children":[]}],"breadcrumbs":[{"docname":"topics/index","title":"使用 Django","url":"/zh-hans/5.2/topics/"},{"docname":"topics/testing/index","title":"Django 中的测试","url":"/zh-hans/5.2/topics/testing/"}],"prev":{"docname":"topics/testing/overview","title":"编写并运行测试","url":"/zh-hans/5.2/topics/testing/overview/"},"next":{"docname":"topics/testing/advanced","title":"进阶测试主题","url":"/zh-hans/5.2/topics/testing/advanced/"},"formats":{"html":"/zh-hans/5.2/topics/testing/tools/","markdown":"/zh-hans/5.2/topics/testing/tools.md","json":"/zh-hans/5.2/topics/testing/tools.json"},"source":"https://github.com/django/django/blob/stable/5.2.x/docs/topics/testing/tools.txt","official":"https://docs.djangoproject.com/zh-hans/5.2/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"],"inLocales":["en","sv","zh-hans","ga","fr","ja","id","it","pt-br","ko","es","el","pl"]}![\"Django](\"../../../../../../_images/django_unittest_classes_hierarchy.svg\")
\n\n