The unit testing framework was originally inspired by JUnit and has a similar flavor as major unit testing frameworks in other languages. It supports test automation, sharing of setup and shutdown code for tests, aggregation of tests into collections, and independence of the tests from the reporting framework
To achieve this, supports some important concepts in an object-oriented way
test fixtureA test fixture represents the preparation needed to perform one or more tests, and any associated cleanup actions. This may involve, for example, creating temporary or proxy databases, directories, or starting a server process
test caseA test case is the individual unit of testing. It checks for a specific response to a particular set of inputs. provides a base class, , which may be used to create new test cases
test suiteA test suite is a collection of test cases, test suites, or both. It is used to aggregate tests that should be executed together
test runnerA test runner is a component which orchestrates the execution of tests and provides the outcome to the user. The runner may use a graphical interface, a textual interface, or return a special value to indicate the results of executing the tests
See also
ModuleAnother test-support module with a very different flavor
Simple Smalltalk Testing. With PatternsBài báo gốc của Kent Beck về các khung thử nghiệm sử dụng mẫu được chia sẻ bởi
pytestThird-party unittest framework with a lighter-weight syntax for writing tests. For example,
python -m unittest -v test_module6The Python Testing Tools Taxonomy
An extensive list of Python testing tools including functional testing frameworks and mock object libraries
Testing in Python Mailing ListA special-interest-group for discussion of testing, and testing tools, in Python
The script
python -m unittest -v test_module7 in the Python source distribution is a GUI tool for test discovery and execution. This is intended largely for ease of use for those new to unit testing. Đối với môi trường sản xuất, các thử nghiệm nên được điều khiển bởi một hệ thống tích hợp liên tục như Buildbot, Jenkins, GitHub Actions hoặc AppVeyor
Ví dụ cơ bản
Mô-đun này cung cấp một bộ công cụ phong phú để xây dựng và chạy thử nghiệm. This section demonstrates that a small subset of the tools suffice to meet the needs of most users
Here is a short script to test three string methods
import unittest class TestStringMethods[unittest.TestCase]: def test_upper[self]: self.assertEqual['foo'.upper[], 'FOO'] def test_isupper[self]: self.assertTrue['FOO'.isupper[]] self.assertFalse['Foo'.isupper[]] def test_split[self]: s = 'hello world' self.assertEqual[s.split[], ['hello', 'world']] # check that s.split fails when the separator is not a string with self.assertRaises[TypeError]: s.split[2] if __name__ == '__main__': unittest.main[]
A testcase is created by subclassing . The three individual tests are defined with methods whose names start with the letters
python -m unittest0. This naming convention informs the test runner about which methods represent tests
The crux of each test is a call to to check for an expected result; or to verify a condition; or to verify that a specific exception gets raised. These methods are used instead of the statement so the test runner can accumulate all test results and produce a report
The and methods allow you to define instructions that will be executed before and after each test method. They are covered in more detail in the section
The final block shows a simple way to run the tests. provides a command-line interface to the test script. When run from the command line, the above script produces an output that looks like this
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK
Passing the
python -m unittest9 option to your test script will instruct to enable a higher level of verbosity, and produce the following output
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK
The above examples show the most commonly used features which are sufficient to meet many everyday testing needs. The remainder of the documentation explores the full feature set from first principles
Changed in version 3. 11. The behavior of returning a value from a test method [other than the default
python -m unittest -h2 value], is now deprecated.
Command-Line Interface
The unittest module can be used from the command line to run tests from modules, classes or even individual test methods
python -m unittest test_module1 test_module2 python -m unittest test_module.TestClass python -m unittest test_module.TestClass.test_method
You can pass in a list with any combination of module names, and fully qualified class or method names
Các mô-đun thử nghiệm cũng có thể được chỉ định theo đường dẫn tệp
python -m unittest tests/test_something.py
This allows you to use the shell filename completion to specify the test module. The file specified must still be importable as a module. The path is converted to a module name by removing the ‘. py’ and converting path separators into ‘. ’. If you want to execute a test file that isn’t importable as a module you should execute the file directly instead
You can run tests with more detail [higher verbosity] by passing in the -v flag
python -m unittest -v test_module
When executed without arguments is started
python -m unittest
For a list of all the command-line options
python -m unittest -h
Changed in version 3. 2. In earlier versions it was only possible to run individual test methods and not modules or classes.
Command-line options
unittest supports these command-line options
-b, --bufferThe standard output and standard error streams are buffered during the test run. Output during a passing test is discarded. Output is echoed normally on test fail or error and is added to the failure messages
-c, --catchControl-C during the test run waits for the current test to end and then reports all the results so far. A second Control-C raises the normal exception
See for the functions that provide this functionality
-f, --failfastStop the test run on the first error or failure
-kOnly run test methods and classes that match the pattern or substring. This option may be used multiple times, in which case all test cases that match any of the given patterns are included
Patterns that contain a wildcard character [
python -m unittest -h4] are matched against the test name using ; otherwise simple case-sensitive substring matching is used
Patterns are matched against the fully qualified test method name as imported by the test loader
For example,
python -m unittest -h6 matches
python -m unittest -h7,
python -m unittest -h8, but not
python -m unittest -h9--locals
Show local variables in tracebacks
New in version 3. 2. The command-line options
cd project_directory python -m unittest discover0,
cd project_directory python -m unittest discover1 and
cd project_directory python -m unittest discover2 were added.
New in version 3. 5. The command-line option
cd project_directory python -m unittest discover3.
New in version 3. 7. The command-line option
cd project_directory python -m unittest discover4.
The command line can also be used for test discovery, for running all of the tests in a project or just a subset
Test Discovery
New in version 3. 2
Unittest supports simple test discovery. In order to be compatible with test discovery, all of the test files must be or importable from the top-level directory of the project [this means that their filenames must be valid ]
Test discovery is implemented in , but can also be used from the command line. The basic command-line usage is
cd project_directory python -m unittest discover
Note
As a shortcut,
cd project_directory python -m unittest discover6 is the equivalent of
cd project_directory python -m unittest discover7. If you want to pass arguments to test discovery the
cd project_directory python -m unittest discover8 sub-command must be used explicitly
The
cd project_directory python -m unittest discover8 sub-command has the following options-v, --verbose
Báo cáo dài dòng
-s, --start-directory directoryDirectory to start discovery [
python -m unittest discover -s project_directory -p "*_test.py" python -m unittest discover project_directory "*_test.py"0 default]-p, --pattern pattern
Pattern to match test files [
python -m unittest discover -s project_directory -p "*_test.py" python -m unittest discover project_directory "*_test.py"1 default]-t, --top-level-directory directory
Top level directory of project [defaults to start directory]
The , , and options can be passed in as positional arguments in that order. The following two command lines are equivalent
python -m unittest discover -s project_directory -p "*_test.py" python -m unittest discover project_directory "*_test.py"
Cũng như là một đường dẫn, có thể chuyển tên gói, ví dụ:
python -m unittest discover -s project_directory -p "*_test.py" python -m unittest discover project_directory "*_test.py"5, làm thư mục bắt đầu. The package name you supply will then be imported and its location on the filesystem will be used as the start directory
Caution
Test discovery loads tests by importing them. Khi khám phá thử nghiệm đã tìm thấy tất cả các tệp thử nghiệm từ thư mục bắt đầu mà bạn chỉ định, nó sẽ biến các đường dẫn thành tên gói để nhập. For example
python -m unittest discover -s project_directory -p "*_test.py" python -m unittest discover project_directory "*_test.py"6 will be imported as
python -m unittest discover -s project_directory -p "*_test.py" python -m unittest discover project_directory "*_test.py"7
If you have a package installed globally and attempt test discovery on a different copy of the package then the import could happen from the wrong place. If this happens test discovery will warn you and exit
Nếu bạn cung cấp thư mục bắt đầu dưới dạng tên gói thay vì đường dẫn đến thư mục thì khám phá giả định rằng bất kỳ vị trí nào nó nhập từ đó đều là vị trí bạn dự định, vì vậy bạn sẽ không nhận được cảnh báo
Test modules and packages can customize test loading and discovery by through the
Đã thay đổi trong phiên bản 3. 4. Kiểm tra hỗ trợ khám phá cho thư mục bắt đầu. Lưu ý rằng bạn cũng cần chỉ định thư mục cấp cao nhất [e. g.
python -m unittest discover -s project_directory -p "*_test.py" python -m unittest discover project_directory "*_test.py"8].
Đã thay đổi trong phiên bản 3. 11. Trăn 3. 11 bỏ hỗ trợ. Nó đã bị hỏng kể từ Python 3. 7. Thư mục bắt đầu và thư mục con chứa các bài kiểm tra phải là gói thông thường có tệp
python -m unittest discover -s project_directory -p "*_test.py" python -m unittest discover project_directory "*_test.py"9.
Các thư mục chứa thư mục bắt đầu vẫn có thể là một gói không gian tên. Trong trường hợp này, bạn cần chỉ định thư mục bắt đầu là tên gói chấm và thư mục đích một cách rõ ràng. Ví dụ
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK0
Tổ chức mã kiểm tra
Các khối xây dựng cơ bản của thử nghiệm đơn vị là các trường hợp thử nghiệm - các kịch bản đơn lẻ phải được thiết lập và kiểm tra tính chính xác. Trong , các trường hợp thử nghiệm được đại diện bởi các trường hợp. Để tạo các trường hợp thử nghiệm của riêng bạn, bạn phải viết các lớp con của hoặc sử dụng
Mã thử nghiệm của một phiên bản phải hoàn toàn khép kín, sao cho mã có thể được chạy độc lập hoặc kết hợp tùy ý với bất kỳ số lượng trường hợp thử nghiệm nào khác
Lớp con đơn giản nhất sẽ thực hiện một phương thức thử nghiệm [i. e. một phương thức có tên bắt đầu bằng
python -m unittest0] để thực hiện mã kiểm tra cụ thể
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK1
Lưu ý rằng để kiểm tra điều gì đó, chúng ta sử dụng một trong các phương thức
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK07 do lớp cơ sở cung cấp. Nếu thử nghiệm không thành công, một ngoại lệ sẽ được đưa ra với thông báo giải thích và sẽ xác định trường hợp thử nghiệm là không thành công. Bất kỳ trường hợp ngoại lệ nào khác sẽ được coi là lỗi
Các thử nghiệm có thể rất nhiều và thiết lập của chúng có thể lặp đi lặp lại. May mắn thay, chúng ta có thể xác định mã thiết lập bằng cách triển khai một phương thức có tên , mà khung thử nghiệm sẽ tự động gọi cho mọi thử nghiệm đơn lẻ mà chúng ta chạy
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK2
Note
Thứ tự chạy các thử nghiệm khác nhau được xác định bằng cách sắp xếp tên phương thức thử nghiệm theo thứ tự tích hợp sẵn cho chuỗi
Nếu phương thức đưa ra một ngoại lệ trong khi thử nghiệm đang chạy, khung sẽ coi thử nghiệm đó đã bị lỗi và phương thức thử nghiệm sẽ không được thực thi
Tương tự như vậy, chúng ta có thể cung cấp một phương thức dọn dẹp sau khi chạy phương thức thử nghiệm
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK3
Nếu thành công, sẽ được chạy cho dù phương thức thử nghiệm có thành công hay không
Môi trường làm việc cho mã kiểm tra như vậy được gọi là vật cố kiểm tra. Một phiên bản TestCase mới được tạo dưới dạng một lịch thi thử duy nhất được sử dụng để thực thi từng phương thức thử nghiệm riêng lẻ. Do đó, , và
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK17 sẽ được gọi một lần cho mỗi bài kiểm tra
Bạn nên sử dụng triển khai TestCase để nhóm các bài kiểm tra lại với nhau theo các tính năng mà chúng kiểm tra. cung cấp một cơ chế cho việc này. bộ kiểm tra, được đại diện bởi lớp của s. Trong hầu hết các trường hợp, việc gọi sẽ thực hiện đúng và thu thập tất cả các trường hợp thử nghiệm của mô-đun cho bạn và thực hiện chúng
Tuy nhiên, nếu bạn muốn tùy chỉnh việc xây dựng bộ thử nghiệm của mình, bạn có thể tự làm điều đó
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK4
Bạn có thể đặt các định nghĩa về trường hợp kiểm tra và bộ kiểm tra trong cùng một mô-đun như mã mà chúng sẽ kiểm tra [chẳng hạn như
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK22], nhưng có một số lợi thế khi đặt mã kiểm tra trong một mô-đun riêng biệt, chẳng hạn như
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK23
Mô-đun thử nghiệm có thể chạy độc lập từ dòng lệnh
Có thể dễ dàng tách mã kiểm tra khỏi mã vận chuyển hơn
Ít bị cám dỗ thay đổi mã kiểm tra để phù hợp với mã mà nó kiểm tra mà không có lý do chính đáng
Mã kiểm tra nên được sửa đổi ít thường xuyên hơn nhiều so với mã mà nó kiểm tra
Mã được kiểm tra có thể được cấu trúc lại dễ dàng hơn
Các bài kiểm tra cho các mô-đun được viết bằng C dù sao cũng phải ở các mô-đun riêng biệt, vậy tại sao không nhất quán?
Nếu chiến lược thử nghiệm thay đổi, không cần thay đổi mã nguồn
Sử dụng lại mã kiểm tra cũ
Một số người dùng sẽ thấy rằng họ có sẵn mã kiểm tra mà họ muốn chạy từ đó mà không cần chuyển đổi mọi chức năng kiểm tra cũ thành một lớp con
Vì lý do này, cung cấp một lớp. Lớp con này có thể được sử dụng để bọc một chức năng kiểm tra hiện có. Chức năng thiết lập và phá bỏ cũng có thể được cung cấp
Đưa ra chức năng kiểm tra sau
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK5
người ta có thể tạo một trường hợp thử nghiệm tương đương như sau, với các phương pháp thiết lập và phá bỏ tùy chọn
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK6
Note
Mặc dù có thể được sử dụng để nhanh chóng chuyển đổi cơ sở thử nghiệm hiện có sang hệ thống dựa trên -, phương pháp này không được khuyến nghị. Dành thời gian để thiết lập các lớp con phù hợp sẽ giúp việc tái cấu trúc thử nghiệm trong tương lai dễ dàng hơn rất nhiều
Trong một số trường hợp, các bài kiểm tra hiện có có thể đã được viết bằng mô-đun. Nếu vậy, hãy cung cấp một lớp
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK34 có thể tự động xây dựng các thể hiện từ các bài kiểm tra dựa trên - hiện có
Bỏ qua các bài kiểm tra và thất bại dự kiến
Mới trong phiên bản 3. 1
Unittest hỗ trợ bỏ qua các phương pháp kiểm tra riêng lẻ và thậm chí cả lớp kiểm tra. Ngoài ra, nó hỗ trợ đánh dấu một bài kiểm tra là "lỗi dự kiến", một bài kiểm tra bị hỏng và sẽ không đạt, nhưng không được tính là lỗi trên một
Bỏ qua một bài kiểm tra chỉ đơn giản là vấn đề sử dụng hoặc một trong các biến thể có điều kiện của nó, gọi trong một hoặc phương thức kiểm tra hoặc tăng trực tiếp
Bỏ qua cơ bản trông như thế này
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK7
Đây là kết quả của việc chạy ví dụ trên ở chế độ dài dòng
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK8
Các lớp có thể được bỏ qua giống như các phương thức
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK9
cũng có thể bỏ qua bài kiểm tra. Điều này hữu ích khi không có tài nguyên cần thiết lập
lỗi dự kiến sử dụng trình trang trí
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK0
Thật dễ dàng để tạo các trình trang trí bỏ qua của riêng bạn bằng cách tạo một trình trang trí gọi bài kiểm tra khi nó muốn nó bị bỏ qua. Trình trang trí này bỏ qua bài kiểm tra trừ khi đối tượng được thông qua có một thuộc tính nhất định
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK1
Các trình trang trí và ngoại lệ sau thực hiện bỏ qua kiểm tra và các lỗi dự kiến
@đơn vị kiểm tra. bỏ qua[lý do]Vô điều kiện bỏ qua bài kiểm tra trang trí. lý do nên mô tả lý do tại sao bài kiểm tra bị bỏ qua
@đơn vị kiểm tra. skipIf[điều kiện , lý do]Bỏ qua bài kiểm tra trang trí nếu điều kiện là đúng
@đơn vị kiểm tra. skipUnless[điều kiện , lý do]Bỏ qua bài kiểm tra trang trí trừ khi điều kiện là đúng
@đơn vị kiểm tra. expectedFailureĐánh dấu bài kiểm tra là lỗi hoặc lỗi dự kiến. Nếu thử nghiệm thất bại hoặc lỗi trong chính chức năng thử nghiệm [chứ không phải ở một trong các phương pháp cố định thử nghiệm] thì nó sẽ được coi là thành công. Nếu vượt qua bài kiểm tra, nó sẽ được coi là thất bại
ngoại lệ đơn vị kiểm tra. SkipTest[lý do]Ngoại lệ này được đưa ra để bỏ qua một bài kiểm tra
Thông thường, bạn có thể sử dụng hoặc một trong các trình trang trí bỏ qua thay vì nâng trực tiếp điều này
Các bài kiểm tra bị bỏ qua sẽ không có hoặc chạy xung quanh chúng. Các lớp học bị bỏ qua sẽ không có hoặc chạy. Các mô-đun bị bỏ qua sẽ không chạy được
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK50 hoặc
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK51
Phân biệt các lần lặp kiểm tra bằng cách sử dụng phép trừ
Mới trong phiên bản 3. 4
Khi có sự khác biệt rất nhỏ giữa các bài kiểm tra của bạn, chẳng hạn như một số tham số, unittest cho phép bạn phân biệt chúng bên trong phần thân của phương pháp kiểm tra bằng trình quản lý ngữ cảnh
Ví dụ, bài kiểm tra sau
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK2
sẽ tạo ra đầu ra sau
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK3
Nếu không sử dụng phép thử phụ, quá trình thực thi sẽ dừng sau lỗi đầu tiên và lỗi sẽ khó chẩn đoán hơn vì giá trị của
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK53 sẽ không được hiển thị
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK4
Các lớp và chức năng
Phần này mô tả sâu về API của
trường hợp thử nghiệm
lớp đơn vị kiểm tra. TestCase[tên phương thức=']Các thể hiện của lớp đại diện cho các đơn vị kiểm tra logic trong vũ trụ. Lớp này dự định sẽ được sử dụng làm lớp cơ sở, với các thử nghiệm cụ thể được thực hiện bởi các lớp con cụ thể. Lớp này triển khai giao diện cần thiết cho người chạy thử nghiệm để cho phép nó thực hiện các bài kiểm tra và các phương thức mà mã kiểm tra có thể sử dụng để kiểm tra và báo cáo các loại lỗi khác nhau
Mỗi phiên bản sẽ chạy một phương thức cơ sở duy nhất. phương thức có tên methodName. Trong hầu hết các trường hợp sử dụng , bạn sẽ không thay đổi tên phương thức cũng như không triển khai lại phương thức
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK59 mặc định
Đã thay đổi trong phiên bản 3. 2. có thể được khởi tạo thành công mà không cần cung cấp tên phương thức. Điều này giúp việc thử nghiệm từ trình thông dịch tương tác trở nên dễ dàng hơn.
trường hợp cung cấp ba nhóm phương pháp. một nhóm được sử dụng để chạy thử nghiệm, một nhóm khác được triển khai thử nghiệm sử dụng để kiểm tra các điều kiện và báo cáo lỗi và một số phương pháp điều tra cho phép thu thập thông tin về bản thân thử nghiệm
Các phương thức trong nhóm đầu tiên [đang chạy thử nghiệm] là
thiết lập[]Phương pháp được gọi để chuẩn bị vật cố định thử nghiệm. Điều này được gọi ngay trước khi gọi phương thức thử nghiệm; . Việc thực hiện mặc định không có gì
xé xuống[]Phương thức được gọi ngay sau khi phương thức kiểm tra được gọi và kết quả được ghi lại. Điều này được gọi ngay cả khi phương thức kiểm tra đưa ra một ngoại lệ, vì vậy việc triển khai trong các lớp con có thể cần phải đặc biệt cẩn thận về việc kiểm tra trạng thái bên trong. Bất kỳ ngoại lệ nào, ngoại trừ or , được đưa ra bởi phương pháp này sẽ được coi là lỗi bổ sung thay vì lỗi kiểm tra [do đó làm tăng tổng số lỗi được báo cáo]. Phương thức này sẽ chỉ được gọi nếu thành công, bất kể kết quả của phương thức thử nghiệm là gì. Việc thực hiện mặc định không có gì
setUpClass[]Một phương thức lớp được gọi trước khi các bài kiểm tra trong một lớp riêng lẻ được chạy.
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK68 được gọi với lớp là đối số duy nhất và phải được trang trí như một
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK5
Xem để biết thêm chi tiết
New in version 3. 2
tearDownClass[]Một phương thức lớp được gọi sau khi các bài kiểm tra trong một lớp riêng lẻ đã chạy.
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK70 được gọi với lớp là đối số duy nhất và phải được trang trí như một
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK6
Xem để biết thêm chi tiết
New in version 3. 2
chạy[kết quả=Không có]Chạy thử nghiệm, thu thập kết quả vào đối tượng được truyền dưới dạng kết quả. Nếu result bị bỏ qua hoặc
python -m unittest -h2, một đối tượng result tạm thời được tạo [bằng cách gọi phương thức] và được sử dụng. Đối tượng kết quả được trả về cho người gọi
Có thể có tác dụng tương tự bằng cách gọi thể hiện
Đã thay đổi trong phiên bản 3. 3. Các phiên bản trước của
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK77 không trả về kết quả. Không gọi một ví dụ. skipTest[lý do]
Gọi điều này trong một phương pháp thử nghiệm hoặc bỏ qua thử nghiệm hiện tại. Xem để biết thêm thông tin
Mới trong phiên bản 3. 1
subTest[tin nhắn=Không có, **params]Trả về trình quản lý bối cảnh thực thi khối mã kèm theo dưới dạng phép thử phụ. msg và params là các giá trị tùy ý, tùy chọn được hiển thị bất cứ khi nào một phép thử phụ không thành công, cho phép bạn xác định chúng một cách rõ ràng
Một trường hợp kiểm tra có thể chứa bất kỳ số lượng khai báo kiểm tra con nào và chúng có thể được lồng vào nhau tùy ý
Xem để biết thêm thông tin
Mới trong phiên bản 3. 4
gỡ lỗi[]Chạy thử nghiệm mà không thu thập kết quả. Điều này cho phép các ngoại lệ do thử nghiệm đưa ra được truyền tới người gọi và có thể được sử dụng để hỗ trợ chạy thử nghiệm trong trình gỡ lỗi
Lớp này cung cấp một số phương thức xác nhận để kiểm tra và báo cáo lỗi. Bảng sau liệt kê các phương pháp được sử dụng phổ biến nhất [xem các bảng bên dưới để biết thêm các phương pháp xác nhận]
Phương pháp
Kiểm tra xem
Mới
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK81
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK83
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK85
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK87
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK89
3. 1
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK91
3. 1
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK93
3. 1
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK95
3. 1
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK97
3. 1
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK99
3. 1
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK01
3. 2
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK03
3. 2
Tất cả các phương thức xác nhận đều chấp nhận một đối số msg, nếu được chỉ định, được sử dụng làm thông báo lỗi khi thất bại [xem thêm]. Lưu ý rằng đối số từ khóa msg chỉ có thể được chuyển đến , , , khi chúng được sử dụng làm trình quản lý ngữ cảnh
assertEqual[đầu tiên , thứ hai, msg=None]Kiểm tra xem thứ nhất và thứ hai có bằng nhau không. Nếu các giá trị không so sánh bằng nhau, thử nghiệm sẽ thất bại
Ngoài ra, nếu thứ nhất và thứ hai là cùng một loại chính xác và một trong danh sách, tuple, dict, set, freezeset hoặc str hoặc bất kỳ loại nào mà một lớp con đăng ký với hàm đẳng thức dành riêng cho loại sẽ được gọi để tạo ra một loại hữu ích hơn
Đã thay đổi trong phiên bản 3. 1. Đã thêm tính năng tự động gọi hàm đẳng thức theo loại cụ thể.
Đã thay đổi trong phiên bản 3. 2. được thêm làm hàm đẳng thức kiểu mặc định để so sánh các chuỗi.
assertNotEqual[đầu tiên , thứ hai, msg=None]Kiểm tra thứ nhất và thứ hai không bằng nhau. Nếu các giá trị so sánh bằng nhau, thử nghiệm sẽ thất bại
assertTrue[expr , tin nhắn=None]assertFalse[expr, msg=None]Kiểm tra xem expr có đúng [hoặc sai]
Lưu ý rằng điều này tương đương với
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK11 chứ không phải với
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK12 [sử dụng
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK13 cho trường hợp sau]. Phương pháp này cũng nên tránh khi có sẵn các phương pháp cụ thể hơn [e. g.
... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK80 thay vì
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK15], bởi vì chúng cung cấp thông báo lỗi tốt hơn trong trường hợp không thành côngassertIs[đầu tiên , thứ hai, msg=None]assertIsNot[first, second, msg=None]
Kiểm tra xem thứ nhất và thứ hai có phải [hoặc không] cùng một đối tượng không
Mới trong phiên bản 3. 1
assertIsNone[expr , tin nhắn=None]assertIsNotNone[expr, msg=None]Kiểm tra xem expr có [hoặc không]
python -m unittest -h2
Mới trong phiên bản 3. 1
assertIn[thành viên , vùng chứa, msg=None]assertNotIn[member, container, msg=None]Kiểm tra thành viên đó có [hoặc không] trong vùng chứa
Mới trong phiên bản 3. 1
assertIsInstance[obj , cls, msg=None]assertNotIsInstance[obj, cls, msg=None]Kiểm tra xem obj có phải [hoặc không] là một thể hiện của cls [có thể là một lớp hoặc một bộ lớp, như được hỗ trợ bởi ]. Để kiểm tra loại chính xác, hãy sử dụng
New in version 3. 2
Cũng có thể kiểm tra việc tạo ra các ngoại lệ, cảnh báo và thông báo nhật ký bằng các phương pháp sau
Phương pháp
Kiểm tra xem
Mới
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK20 tăng đột xuất
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK20 tăng exc và thông báo khớp với regex r
3. 1
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK20 tăng cảnh báo
3. 2
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK20 tăng cảnh báo và thông báo khớp với regex r
3. 2
Khối
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK28 ghi nhật ký trên logger với mức tối thiểu
3. 4
Khốitest_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK28 không đăng nhập
logger với mức tối thiểu
3. 10
assertRaises[ngoại lệ , có thể gọi, *args, **kwds]assertRaises[exception, *, msg=None]Kiểm tra xem một ngoại lệ có được đưa ra khi có thể gọi được gọi với bất kỳ đối số vị trí hoặc từ khóa nào cũng được chuyển đến. Thử nghiệm vượt qua nếu ngoại lệ được đưa ra, là lỗi nếu một ngoại lệ khác được đưa ra hoặc không thành công nếu không có ngoại lệ nào được đưa ra. Để bắt bất kỳ nhóm ngoại lệ nào, một bộ chứa các lớp ngoại lệ có thể được chuyển thành ngoại lệ
Nếu chỉ có ngoại lệ và có thể đối số msg được cung cấp, hãy trả về trình quản lý ngữ cảnh để mã được kiểm tra có thể được viết nội tuyến thay vì dưới dạng hàm
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK7
Khi được sử dụng làm trình quản lý ngữ cảnh, hãy chấp nhận thông báo đối số từ khóa bổ sung
Trình quản lý ngữ cảnh sẽ lưu trữ đối tượng ngoại lệ đã bắt được trong thuộc tính
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK33 của nó. Điều này có thể hữu ích nếu mục đích là thực hiện kiểm tra bổ sung đối với ngoại lệ được đưa ra
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK8
Đã thay đổi trong phiên bản 3. 1. Đã thêm khả năng sử dụng làm trình quản lý ngữ cảnh.
Đã thay đổi trong phiên bản 3. 2. Đã thêm thuộc tính
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK33.
Đã thay đổi trong phiên bản 3. 3. Đã thêm đối số từ khóa msg khi được sử dụng làm trình quản lý ngữ cảnh.
assertRaisesRegex[ngoại lệ , regex, callable, *args, **kwds]assertRaisesRegex[exception, regex, *, msg=None]Thích nhưng cũng kiểm tra regex khớp với biểu diễn chuỗi của ngoại lệ đã nêu. regex có thể là một đối tượng biểu thức chính quy hoặc một chuỗi chứa biểu thức chính quy phù hợp để sử dụng bởi. ví dụ
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK9
hoặc là
python -m unittest test_module1 test_module2 python -m unittest test_module.TestClass python -m unittest test_module.TestClass.test_method0
Mới trong phiên bản 3. 1. Đã thêm dưới tên
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK38.
Đã thay đổi trong phiên bản 3. 2. Đã đổi tên thành.
Đã thay đổi trong phiên bản 3. 3. Đã thêm đối số từ khóa msg khi được sử dụng làm trình quản lý ngữ cảnh.
assertWarns[cảnh báo , có thể gọi, *args, **kwds]assertWarns[warning, *, msg=None]Kiểm tra xem cảnh báo có được kích hoạt khi có thể gọi được gọi với bất kỳ đối số vị trí hoặc từ khóa nào cũng được chuyển đến. Kiểm tra vượt qua nếu cảnh báo được kích hoạt và không thành công nếu không. Bất kỳ ngoại lệ là một lỗi. Để nắm bắt bất kỳ nhóm cảnh báo nào, một bộ chứa các lớp cảnh báo có thể được chuyển dưới dạng cảnh báo
Nếu chỉ đưa ra cảnh báo và có thể là các đối số msg, hãy trả về trình quản lý ngữ cảnh để mã được kiểm tra có thể được viết nội tuyến thay vì dưới dạng một hàm
python -m unittest test_module1 test_module2 python -m unittest test_module.TestClass python -m unittest test_module.TestClass.test_method1
Khi được sử dụng làm trình quản lý ngữ cảnh, hãy chấp nhận thông báo đối số từ khóa bổ sung
Trình quản lý bối cảnh sẽ lưu trữ đối tượng cảnh báo bị bắt trong thuộc tính
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK42 của nó và dòng nguồn đã kích hoạt cảnh báo trong thuộc tính
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK43 và
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK44. Điều này có thể hữu ích nếu mục đích là thực hiện kiểm tra bổ sung đối với cảnh báo bị bắt
python -m unittest test_module1 test_module2 python -m unittest test_module.TestClass python -m unittest test_module.TestClass.test_method2
Phương pháp này hoạt động bất kể các bộ lọc cảnh báo tại chỗ khi nó được gọi
New in version 3. 2
Đã thay đổi trong phiên bản 3. 3. Đã thêm đối số từ khóa msg khi được sử dụng làm trình quản lý ngữ cảnh.
assertWarnsRegex[cảnh báo , regex, callable, *args, **kwds]assertWarnsRegex[warning, regex, *, msg=None]Thích nhưng cũng kiểm tra regex khớp với thông báo của cảnh báo được kích hoạt. regex có thể là một đối tượng biểu thức chính quy hoặc một chuỗi chứa biểu thức chính quy phù hợp để sử dụng bởi. Thí dụ
python -m unittest test_module1 test_module2 python -m unittest test_module.TestClass python -m unittest test_module.TestClass.test_method3
hoặc là
python -m unittest test_module1 test_module2 python -m unittest test_module.TestClass python -m unittest test_module.TestClass.test_method4
New in version 3. 2
Đã thay đổi trong phiên bản 3. 3. Đã thêm đối số từ khóa msg khi được sử dụng làm trình quản lý ngữ cảnh.
assertLogs[logger=Không có, level=None]Trình quản lý ngữ cảnh để kiểm tra xem có ít nhất một thông báo được ghi vào bộ ghi hoặc một trong các phần tử con của nó không, với ít nhất một mức nhất định
Nếu được cung cấp, logger phải là một đối tượng hoặc đặt tên của logger. Mặc định là trình ghi nhật ký gốc, trình ghi nhật ký này sẽ bắt tất cả các thư không bị chặn bởi trình ghi nhật ký con cháu không lan truyền
Nếu được cung cấp, cấp phải là cấp ghi số hoặc chuỗi tương đương [ví dụ:
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK49 hoặc
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK50]. Mặc định là
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK51
Thử nghiệm vượt qua nếu ít nhất một thông báo được phát ra bên trong khối
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK28 phù hợp với điều kiện cấp độ và bộ ghi, nếu không thì không thành công
Đối tượng được trả về bởi trình quản lý bối cảnh là một trình trợ giúp ghi âm giúp theo dõi các thông điệp nhật ký phù hợp. Nó có hai thuộc tính
Hồ sơMột danh sách các đối tượng của các thông điệp bản ghi phù hợp
đầu raMột danh sách các đối tượng có đầu ra được định dạng của các thông báo phù hợp
Thí dụ
python -m unittest test_module1 test_module2 python -m unittest test_module.TestClass python -m unittest test_module.TestClass.test_method5
Mới trong phiên bản 3. 4
assertNoLogs[logger=Không có, level=None]Trình quản lý ngữ cảnh để kiểm tra xem không có thông báo nào được ghi vào trình ghi nhật ký hoặc một trong các phần tử con của nó, với ít nhất một mức nhất định
Nếu được cung cấp, logger phải là một đối tượng hoặc đặt tên của logger. Mặc định là root logger, sẽ bắt tất cả các tin nhắn
Nếu được cung cấp, cấp phải là cấp ghi số hoặc chuỗi tương đương [ví dụ:
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK49 hoặc
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK50]. Mặc định là
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK51
Không giống như , trình quản lý bối cảnh sẽ không trả lại gì
Mới trong phiên bản 3. 10
Ngoài ra còn có các phương pháp khác được sử dụng để thực hiện kiểm tra cụ thể hơn, chẳng hạn như
Phương pháp
Kiểm tra xem
Mới
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK62
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK64
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK66
3. 1
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK68
3. 1
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK70
3. 1
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK72
3. 1
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK74
3. 1
test_isupper [__main__.TestStringMethods.test_isupper] ... ok test_split [__main__.TestStringMethods.test_split] ... ok test_upper [__main__.TestStringMethods.test_upper] ... ok ---------------------------------------------------------------------- Ran 3 tests in 0.001s OK76
3. 2
a và b có cùng phần tử trong cùng một số, bất kể thứ tự của chúng
3. 2
assertAlmostEqual[đầu tiên , thứ hai, places=7, msg=None, delta=None]assertNotAlmostEqual[first, second, places=7, msg=None, delta=None]Kiểm tra xem thứ nhất và thứ hai có xấp xỉ [hoặc không xấp xỉ] bằng nhau bằng cách tính chênh lệch, làm tròn đến số vị trí thập phân đã cho [mặc định là 7] và so sánh với 0. Lưu ý rằng các phương pháp này làm tròn các giá trị đến số vị trí thập phân đã cho [i. e. như hàm] và các chữ số không có nghĩa
Nếu delta được cung cấp thay vì vị trí thì chênh lệch giữa thứ nhất và thứ hai phải nhỏ hơn hoặc bằng [hoặc lớn hơn] delta
Cung cấp cả đồng bằng và địa điểm làm tăng
Đã thay đổi trong phiên bản 3. 2. tự động xem xét các đối tượng gần như bằng nhau để so sánh bằng nhau. tự động thất bại nếu các đối tượng so sánh bằng nhau. Đã thêm đối số từ khóa delta.
assertGreater[thứ nhất , thứ hai, msg=None]assertGreaterEqual[first, second, msg=None]assertLess[first, second, msg=None]assertLessEqual[first, second, msg=None]Kiểm tra cái đầu tiên tương ứng là >, >=, < hoặc