Kiểm tra Python với pytest pdf GitHub

Khung kiểm tra đơn vị ban đầu được lấy cảm hứng từ JUnit và có hương vị tương tự như các khung kiểm tra đơn vị chính trong các ngôn ngữ khác. Nó hỗ trợ tự động hóa thử nghiệm, chia sẻ mã thiết lập và tắt cho các thử nghiệm, tổng hợp các thử nghiệm thành các bộ sưu tập và tính độc lập của các thử nghiệm với khung báo cáo

Nội dung chính Show

Ví dụ cơ bản
Giao diện dòng lệnh
Tùy chọn dòng lệnh
khám phá thử nghiệm
Tổ chức mã kiểm tra
Sử dụng lại mã kiểm tra cũ
Bỏ qua các bài kiểm tra và thất bại dự kiến
Phân biệt các lần lặp kiểm tra bằng cách sử dụng phép trừ
Các lớp và chức năng
trường hợp thử nghiệm
kiểm tra nhóm
Đang tải và chạy thử nghiệm
Đồ đạc lớp và mô-đun
setUpClass vàearDownClass
setUpModule vàearDownModule
Xử lý tín hiệu

Để đạt được điều này, hỗ trợ một số khái niệm quan trọng theo cách hướng đối tượng

lịch thi đấu

Một bộ cố định thử nghiệm thể hiện sự chuẩn bị cần thiết để thực hiện một hoặc nhiều thử nghiệm và bất kỳ hành động dọn dẹp nào có liên quan. Điều này có thể bao gồm, ví dụ, tạo cơ sở dữ liệu tạm thời hoặc proxy, thư mục hoặc khởi động quy trình máy chủ

trường hợp thử nghiệm

Một trường hợp thử nghiệm là đơn vị thử nghiệm riêng lẻ. Nó kiểm tra một phản hồi cụ thể đối với một bộ đầu vào cụ thể. cung cấp một lớp cơ sở, có thể được sử dụng để tạo các trường hợp thử nghiệm mới

bộ kiểm tra

Bộ kiểm thử là tập hợp các trường hợp kiểm thử, bộ kiểm thử hoặc cả hai. Nó được sử dụng để tổng hợp các bài kiểm tra nên được thực hiện cùng nhau

người chạy thử

Trình chạy thử nghiệm là một thành phần điều phối việc thực hiện các thử nghiệm và cung cấp kết quả cho người dùng. Người chạy có thể sử dụng giao diện đồ họa, giao diện văn bản hoặc trả về một giá trị đặc biệt để chỉ ra kết quả thực hiện các bài kiểm tra

Xem thêm

mô-đun

Một mô-đun hỗ trợ thử nghiệm khác với hương vị rất khác

Kiểm tra Smalltalk đơn giản. có hoa văn

Bà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

người khó tính

Khung đơn giản nhất của bên thứ ba với cú pháp nhẹ hơn để viết bài kiểm tra. Ví dụ,

python -m unittest -v test_module

Phân loại công cụ kiểm tra Python

Một danh sách đầy đủ các công cụ kiểm tra Python bao gồm các khung kiểm tra chức năng và thư viện đối tượng giả

Thử nghiệm trong Danh sách gửi thư Python

Một nhóm có sở thích đặc biệt để thảo luận về thử nghiệm và các công cụ thử nghiệm trong Python

Tập lệnh

python -m unittest -v test_module

7 trong bản phân phối nguồn Python là một công cụ GUI để khám phá và thực thi thử nghiệm. Điều này chủ yếu nhằm mục đích dễ sử dụng cho những người mới thử nghiệm đơn vị. Đố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. Phần này chứng minh rằng một tập hợp con nhỏ của các công cụ đủ để đáp ứng nhu cầu của hầu hết người dùng

Đây là một đoạn script ngắn để kiểm tra ba phương thức chuỗi

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()

Một testcase được tạo bằng cách phân lớp. Ba bài kiểm tra riêng lẻ được xác định bằng các phương thức có tên bắt đầu bằng các chữ cái

python -m unittest

0. Quy ước đặt tên này thông báo cho người chạy thử nghiệm về phương thức nào đại diện cho các thử nghiệm

Điểm mấu chốt của mỗi bài kiểm tra là một cuộc gọi để kiểm tra kết quả mong đợi; . Các phương thức này được sử dụng thay cho câu lệnh để người chạy thử nghiệm có thể tích lũy tất cả các kết quả thử nghiệm và tạo báo cáo

Các phương thức và cho phép bạn xác định các lệnh sẽ được thực thi trước và sau mỗi phương thức kiểm tra. Chúng được đề cập chi tiết hơn trong phần

Khối cuối cùng cho thấy một cách đơn giản để chạy thử nghiệm. cung cấp giao diện dòng lệnh cho tập lệnh thử nghiệm. Khi chạy từ dòng lệnh, tập lệnh trên sẽ tạo ra một đầu ra giống như thế này

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

Chuyển tùy chọn

python -m unittest

9 cho tập lệnh thử nghiệm của bạn sẽ hướng dẫn kích hoạt mức độ chi tiết cao hơn và tạo ra kết quả 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

OK

Các ví dụ trên cho thấy các tính năng được sử dụng phổ biến nhất, đủ để đáp ứng nhiều nhu cầu kiểm tra hàng ngày. Phần còn lại của tài liệu khám phá bộ tính năng đầy đủ từ các nguyên tắc đầu tiên

Đã thay đổi trong phiên bản 3. 11. Hành vi trả về một giá trị từ một phương thức kiểm tra (không phải giá trị mặc định

python -m unittest -h

2), hiện không được dùng nữa.

Giao diện dòng lệnh

Mô-đun unittest có thể được sử dụng từ dòng lệnh để chạy thử nghiệm từ các mô-đun, lớp hoặc thậm chí các phương thức thử nghiệm riêng lẻ

________số 8

Bạn có thể chuyển vào một danh sách với bất kỳ sự kết hợp nào của tên mô-đun và tên phương thức hoặc lớp đủ điều kiện

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

Điều này cho phép bạn sử dụng hoàn thành tên tệp shell để chỉ định mô-đun thử nghiệm. Tệp được chỉ định vẫn phải nhập được dưới dạng mô-đun. Đường dẫn được chuyển đổi thành tên mô-đun bằng cách xóa '. py' và chuyển đổi các dấu phân cách đường dẫn thành '. ’. Nếu bạn muốn thực thi tệp thử nghiệm không thể nhập dưới dạng mô-đun, thay vào đó, bạn nên thực thi tệp trực tiếp

Bạn có thể chạy thử nghiệm với nhiều chi tiết hơn (độ chi tiết cao hơn) bằng cách chuyển vào cờ -v

python -m unittest -v test_module

Khi được thực hiện mà không có đối số được bắt đầu

python -m unittest

Để biết danh sách tất cả các tùy chọn dòng lệnh

python -m unittest -h

Đã thay đổi trong phiên bản 3. 2. Trong các phiên bản trước, chỉ có thể chạy các phương thức thử nghiệm riêng lẻ chứ không phải mô-đun hoặc lớp.

Tùy chọn dòng lệnh

unittest hỗ trợ các tùy chọn dòng lệnh này

-b, --bộ đệm

Đầu ra tiêu chuẩn và các luồng lỗi tiêu chuẩn được lưu vào bộ đệm trong quá trình chạy thử nghiệm. Đầu ra trong một bài kiểm tra vượt qua bị loại bỏ. Đầu ra được lặp lại bình thường khi kiểm tra lỗi hoặc lỗi và được thêm vào thông báo lỗi

-c, --bắt

Control-C trong quá trình chạy thử, đợi thử nghiệm hiện tại kết thúc rồi báo cáo tất cả các kết quả cho đến nay. Control-C thứ hai tăng ngoại lệ bình thường

Xem các chức năng cung cấp chức năng này

-f, --không thành công

Dừng chạy thử khi có lỗi hoặc lỗi đầu tiên

-k

Chỉ chạy thử nghiệm các phương thức và lớp phù hợp với mẫu hoặc chuỗi con. Tùy chọn này có thể được sử dụng nhiều lần, trong trường hợp đó, tất cả các trường hợp thử nghiệm khớp với bất kỳ mẫu nào đã cho đều được bao gồm

Các mẫu có chứa ký tự đại diện (_______74) được so khớp với tên bài kiểm tra bằng cách sử dụng ;

Các mẫu được so khớp với tên phương thức kiểm tra đủ điều kiện do trình tải kiểm tra nhập vào

Ví dụ:

python -m unittest -h

6 khớp với

python -m unittest -h

python -m unittest -h

8, nhưng không khớp với

python -m unittest -h

--locals

Hiển thị các biến cục bộ trong truy nguyên

Mới trong phiên bản 3. 2. Các tùy chọn dòng lệnh

python -m unittest -v test_module

80,

python -m unittest -v test_module

81 và

python -m unittest -v test_module

82 đã được thêm vào.

Mới trong phiên bản 3. 5. Tùy chọn dòng lệnh

python -m unittest -v test_module

83.

Mới trong phiên bản 3. 7. Tùy chọn dòng lệnh

python -m unittest -v test_module

84.

Dòng lệnh cũng có thể được sử dụng để khám phá thử nghiệm, để chạy tất cả các thử nghiệm trong một dự án hoặc chỉ một tập hợp con

khám phá thử nghiệm

Mới trong phiên bản 3. 2

Unittest hỗ trợ khám phá thử nghiệm đơn giản. Để tương thích với khám phá thử nghiệm, tất cả các tệp thử nghiệm phải hoặc có thể nhập được từ thư mục cấp cao nhất của dự án (điều này có nghĩa là tên tệp của chúng phải hợp lệ )

Phát hiện thử nghiệm được triển khai trong , nhưng cũng có thể được sử dụng từ dòng lệnh. Việc sử dụng dòng lệnh cơ bản là

python -m unittest -v test_module

Ghi chú

Là một phím tắt,

python -m unittest -v test_module

86 tương đương với

python -m unittest -v test_module

87. Nếu bạn muốn truyền đối số để kiểm tra khám phá, lệnh phụ

python -m unittest -v test_module

88 phải được sử dụng rõ ràng

Lệnh phụ

python -m unittest -v test_module

88 có các tùy chọn sau

-v, --dài dòng

Báo cáo dài dòng

-s, --thư mục bắt đầu thư mục

Thư mục để bắt đầu khám phá (

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()

80 mặc định)

-p, --mẫu mẫu

Mẫu để khớp với các tệp thử nghiệm (mặc định ____281)

-t, --thư mục cấp cao nhất thư mục

Thư mục cấp cao nhất của dự án (mặc định là thư mục bắt đầu)

Các tùy chọn , và có thể được chuyển vào dưới dạng đối số vị trí theo thứ tự đó. Hai dòng lệnh sau là tương đương

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()

Cũng như là một đường dẫn, có thể chuyển tên gói, ví dụ như

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()

85, làm thư mục bắt đầu. Tên gói bạn cung cấp sau đó sẽ được nhập và vị trí của nó trên hệ thống tệp sẽ được sử dụng làm thư mục bắt đầu

thận trọng

Phát hiện thử nghiệm tải các bài kiểm tra bằng cách nhập chúng. 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. Ví dụ:

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()

86 sẽ được nhập dưới dạng

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()

Nếu bạn đã cài đặt một gói trên toàn cầu và thử khám phá kiểm tra trên một bản sao khác của gói thì quá trình nhập có thể xảy ra từ sai vị trí. Nếu điều này xảy ra, kiểm tra khám phá sẽ cảnh báo bạn và thoát

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

Các mô-đun và gói thử nghiệm có thể tùy chỉnh quá trình tải và khám phá thử nghiệm bằng cách thông qua

Đã 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.

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()

88).

Đã 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

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()

89.

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

OK

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 unittest

0) để thực hiện mã kiểm tra cụ thể

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

Lưu ý rằng để kiểm tra điều gì đó, chúng tôi sử dụng một trong các phương thức

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

07 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

OK

Ghi chú

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

OK

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

OK

17 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

OK

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

OK

22), 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

OK

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 phân lớp

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

OK

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

OK

Ghi chú

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

OK

34 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

OK

Đâ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

OK

Các lớp có thể được bỏ qua giống như các phương thức

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

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

OK

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

OK

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

OK

50 hoặc

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

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 thử nghiệm 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 thức thử nghiệm bằng cách sử dụng trình quản lý bối 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

OK

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

OK

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

OK

53 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

OK

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 methodName cũng như không triển khai lại phương thức

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

59 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

OK

68 đượ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

OK

Xem để biết thêm chi tiết

Mới trong phiên bản 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

OK

70 đượ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

OK

Xem để biết thêm chi tiết

Mới trong phiên bản 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 kết quả bị bỏ qua hoặc

python -m unittest -h

2, một đối tượng kết quả 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

OK

77 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

OK

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

3. 1

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

3. 1

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

3. 1

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

3. 1

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

3. 1

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

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

OK

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

OK

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

OK

11 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

OK

12 (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

OK

13 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

OK

80 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

OK

15), 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ông

assertIs(đầ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 -h

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

Mới trong phiên bản 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

OK

20 tăng ex

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

20 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

OK

20 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

OK

20 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

OK

28 ghi nhật ký trên logger với mức tối thiểu

3. 4

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

OK

28 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ể là đối số msg được đưa ra, 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

OK

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 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

OK

33 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

OK

Đã 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

OK

33.

Đã 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

OK

hoặc

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

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

OK

38.

Đã 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à đối số thông báo, 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

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

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

OK

42 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

OK

43 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

OK

44. Đ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_method

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

Mới trong phiên bản 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. Ví dụ

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

hoặc

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

Mới trong phiên bản 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

OK

49 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

OK

50). 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

OK

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

OK

28 phù hợp với điều kiện cấp độ và trình ghi nhật ký, 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 ra

Mộ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

Ví dụ

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

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

OK

49 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

OK

50). 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

OK

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

OK

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

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

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

OK

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

OK

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

OK

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

OK

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

OK

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 <= so với thứ hai tùy thuộc vào tên phương thức. Nếu không, bài kiểm tra sẽ thất bại

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

Mới trong phiên bản 3. 1

assertRegex(văn bản , regex, msg=None)assertNotRegex(text, regex, msg=None)

Kiểm tra xem tìm kiếm regex khớp (hoặc không khớp) văn bản. Trong trường hợp không thành công, thông báo lỗi sẽ bao gồm mẫu và văn bản (hoặc mẫu và phần văn bản không khớp với nhau). 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

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

OK

83.

Đã thay đổi trong phiên bản 3. 2. Phương thứ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

OK

84 đã được đổi tên thành.

Mới trong phiên bản 3. 2. .

Mới trong phiên bản 3. 5. 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

OK

87 là bí danh không dùng nữa cho.

assertCountEqual(đầu tiên , thứ hai, msg=None)

Kiểm tra trình tự đầu tiên chứa các phần tử giống như thứ hai, bất kể thứ tự của chúng. Khi không, một thông báo lỗi liệt kê sự khác biệt giữa các trình tự sẽ được tạo

Các yếu tố trùng lặp không bị bỏ qua khi so sánh thứ nhất và thứ hai. Nó xác minh xem mỗi phần tử có cùng số lượng trong cả hai chuỗi hay không. 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

OK

89 nhưng cũng hoạt động với các chuỗi đối tượng không thể băm

Mới trong phiên bản 3. 2

Phương thức gửi kiểm tra đẳng thức cho các đối tượng cùng loại đến các phương thức dành riêng cho loại khác nhau. Các phương thức này đã được triển khai cho hầu hết các loại tích hợp sẵn, nhưng cũng có thể đăng ký các phương thức mới bằng cách sử dụng

addTypeEqualityFunc(typeobj , function)

Đăng ký một phương thức dành riêng cho loại được gọi bởi để kiểm tra xem hai đối tượng có cùng loại chính xácobj (không phải lớp con) có so sánh bằng nhau không. chức năng phải nhận hai đối số vị trí và đối số từ khóa thứ ba msg=None cũng giống như vậy. Nó phải tăng lên khi phát hiện thấy sự bất bình đẳng giữa hai tham số đầu tiên – có thể cung cấp thông tin hữu ích và giải thích chi tiết về sự bất bình đẳng trong thông báo lỗi

Mới trong phiên bản 3. 1

Danh sách các phương pháp dành riêng cho loại tự động được sử dụng được tóm tắt trong bảng sau. Lưu ý rằng thường không cần thiết phải gọi trực tiếp các phương thức này

Phương pháp

Dùng để so sánh

Mới

dây

3. 1

trình tự

3. 1

danh sách

3. 1

bộ dữ liệu

3. 1

bộ hoặc bộ đông lạnh

3. 1

mệnh lệnh

3. 1

assertMultiLineEqual(đầu tiên , thứ hai, msg=None)

Kiểm tra xem chuỗi nhiều dòng đầu tiên có bằng chuỗi thứ hai không. Khi không bằng một khác biệt của hai chuỗi làm nổi bật sự khác biệt sẽ được đưa vào thông báo lỗi. Phương pháp này được sử dụng theo mặc định khi so sánh các chuỗi với

Mới trong phiên bản 3. 1

assertSequenceEqual(đầu tiên , thứ hai, msg=None, seq_type=None)

Kiểm tra xem hai dãy có bằng nhau không. Nếu một seq_type được cung cấp, thì cả thứ nhất và thứ hai phải là phiên bản của seq_type nếu không sẽ xảy ra lỗi. Nếu các trình tự khác nhau, một thông báo lỗi sẽ được tạo để hiển thị sự khác biệt giữa hai trình tự

Phương thức này không được gọi trực tiếp bởi , nhưng nó được sử dụng để thực hiện và

Mới trong phiên bản 3. 1

assertListEqual(đầu tiên , thứ hai, msg=None)assertTupleEqual(first, second, msg=None)

Kiểm tra xem hai danh sách hoặc bộ dữ liệu có bằng nhau không. Nếu không, một thông báo lỗi được tạo chỉ hiển thị sự khác biệt giữa hai. Một lỗi cũng được đưa ra nếu một trong các tham số không đúng loại. Các phương thức này được sử dụng theo mặc định khi so sánh danh sách hoặc bộ dữ liệu với

Mới trong phiên bản 3. 1

assertSetEqual(đầu tiên , thứ hai, msg=None)

Kiểm tra xem hai tập hợp có bằng nhau không. Nếu không, một thông báo lỗi được tạo liệt kê sự khác biệt giữa các bộ. Phương pháp này được sử dụng theo mặc định khi so sánh các tập hợp hoặc tập hợp cố định với

Thất bại nếu một trong hai thứ nhất hoặc thứ hai không có phương thức

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

Mới trong phiên bản 3. 1

assertDictEqual(đầu tiên , thứ hai, msg=None)

Kiểm tra xem hai từ điển có bằng nhau không. Nếu không, một thông báo lỗi được tạo cho thấy sự khác biệt trong từ điển. Phương pháp này sẽ được sử dụng theo mặc định để so sánh từ điển trong các cuộc gọi đến

Mới trong phiên bản 3. 1

Cuối cùng, cung cấp các phương thức và thuộc tính sau

không thành công(tin nhắn=Không có)

Báo hiệu lỗi kiểm tra một cách vô điều kiện, với msg hoặc

python -m unittest -h

2 cho thông báo lỗi

failException

Thuộc tính lớp này đưa ra ngoại lệ được đưa ra bởi phương thức kiểm tra. Nếu một khung kiểm tra cần sử dụng một ngoại lệ chuyên biệt, có thể mang thông tin bổ sung, thì nó phải phân lớp ngoại lệ này để “chơi công bằng” với khung. Giá trị ban đầu của thuộc tính này là

tin nhắn dài

Thuộc tính lớp này xác định điều gì sẽ xảy ra khi thông báo lỗi tùy chỉnh được chuyển dưới dạng đối số msg cho lệnh gọi assertXYY không thành công.

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

13 là giá trị mặc định. Trong trường hợp này, thông báo tùy chỉnh được thêm vào cuối thông báo lỗi tiêu chuẩn. Khi được đặt thành

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

14, thông báo tùy chỉnh sẽ thay thế thông báo tiêu chuẩn

Cài đặt lớp có thể được ghi đè trong các phương thức thử nghiệm riêng lẻ bằng cách gán một thuộc tính thể hiện, tự. longMessage, đến

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

13 hoặc

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

14 trước khi gọi các phương thức xác nhận

Cài đặt lớp được đặt lại trước mỗi cuộc gọi thử nghiệm

Mới trong phiên bản 3. 1

maxDiff

Thuộc tính này kiểm soát độ dài tối đa của đầu ra khác biệt bằng cách xác nhận các phương thức báo cáo khác biệt khi thất bại. Nó mặc định là 80*8 ký tự. Các phương thức xác nhận bị ảnh hưởng bởi thuộc tính này là (bao gồm tất cả các phương thức so sánh trình tự ủy quyền cho nó) và

Đặt

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

20 thành

python -m unittest -h

2 có nghĩa là không có độ dài khác biệt tối đa

Mới trong phiên bản 3. 2

Khung kiểm tra có thể sử dụng các phương pháp sau để thu thập thông tin về bài kiểm tra

countTestCases()

Trả về số lượng bài kiểm tra được đại diện bởi đối tượng kiểm tra này. Ví dụ, đây sẽ luôn là

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

defaultTestResult()

Trả về một thể hiện của lớp kết quả thử nghiệm sẽ được sử dụng cho lớp trường hợp thử nghiệm này (nếu không có thể hiện kết quả nào khác được cung cấp cho phương thức)

Ví dụ, đây sẽ luôn là một phiên bản của ;

id()

Trả về một chuỗi xác định trường hợp thử nghiệm cụ thể. Đây thường là tên đầy đủ của phương thức thử nghiệm, bao gồm tên mô-đun và tên lớp

Mô tả ngắn()

Trả về mô tả của bài kiểm tra hoặc

python -m unittest -h

2 nếu không có mô tả nào được cung cấp. Việc triển khai mặc định của phương thức này trả về dòng đầu tiên trong chuỗi tài liệu của phương thức thử nghiệm, nếu có hoặc

python -m unittest -h

Đã thay đổi trong phiên bản 3. 1. Sau 3. 1 điều này đã được thay đổi để thêm tên thử nghiệm vào mô tả ngắn ngay cả khi có chuỗi tài liệu. Điều này gây ra sự cố tương thích với các tiện ích mở rộng không đáng tin cậy nhất và việc thêm tên thử nghiệm đã được chuyển sang trong Python 3. 2.

addCleanup(chức năng , /, *args, **kwargs)

Thêm một chức năng được gọi sau để dọn sạch tài nguyên được sử dụng trong quá trình kiểm tra. Các chức năng sẽ được gọi theo thứ tự ngược lại với thứ tự chúng được thêm vào (LIFO). Chúng được gọi với bất kỳ đối số và đối số từ khóa nào được truyền vào khi chúng được thêm vào

Nếu không thành công, nghĩa là không được gọi, thì mọi chức năng dọn dẹp được thêm vào sẽ vẫn được gọi

Mới trong phiên bản 3. 1

enterContext(cm)

Nhập được cung cấp. Nếu thành công, hãy thêm phương thức của nó làm hàm dọn dẹp và trả về kết quả của phương thức

Mới trong phiên bản 3. 11

doCleanups()

Phương thức này được gọi vô điều kiện sau hoặc sau nếu đưa ra một ngoại lệ

Nó chịu trách nhiệm gọi tất cả các chức năng dọn dẹp được thêm bởi. Nếu bạn cần các chức năng dọn dẹp được gọi trước thì bạn có thể tự gọi cho mình

bật từng phương thức ra khỏi ngăn xếp của các hàm dọn dẹp, vì vậy nó có thể được gọi bất cứ lúc nào

Mới trong phiên bản 3. 1

classmethod addClassCleanup(hàm , /, *args, **kwargs)

Thêm một chức năng được gọi sau để dọn sạch tài nguyên được sử dụng trong lớp kiểm tra. Các chức năng sẽ được gọi theo thứ tự ngược lại với thứ tự chúng được thêm vào (LIFO). Chúng được gọi với bất kỳ đối số và đối số từ khóa nào được truyền vào khi chúng được thêm vào

Nếu không thành công, nghĩa là không được gọi, thì mọi chức năng dọn dẹp được thêm vào sẽ vẫn được gọi

Mới trong phiên bản 3. 8

classmethod enterClassContext(cm)

Nhập được cung cấp. Nếu thành công, hãy thêm phương thức của nó làm hàm dọn dẹp và trả về kết quả của phương thức

Mới trong phiên bản 3. 11

classmethod doClassCleanups()

Phương thức này được gọi vô điều kiện sau hoặc sau nếu đưa ra một ngoại lệ

bật từng phương thức ra khỏi ngăn xếp của các hàm dọn dẹp, vì vậy nó có thể được gọi bất cứ lúc nào

Mới trong phiên bản 3. 8

lớp đơn vị kiểm tra. AsyncioTestCase bị cô lập(tên phương thức=')

Lớp này cung cấp một API tương tự và cũng chấp nhận các coroutine làm chức năng kiểm tra

Mới trong phiên bản 3. 8

coroutine asyncSetUp()

Phương pháp được gọi để chuẩn bị vật cố định thử nghiệm. Cái này được gọi sau

python -m unittest

6. Đ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ì

coroutine asyncTearDown()

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. Cái này được gọi trước

python -m unittest

7. Đ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ì

addAsyncCleanup(chức năng , /, *args, **kwargs)

Phương pháp này chấp nhận một coroutine có thể được sử dụng làm chức năng dọn dẹp

coroutine enterAsyncContext(cm)

Nhập được cung cấp. Nếu thành công, hãy thêm phương thức của nó làm hàm dọn dẹp và trả về kết quả của phương thức

Mới trong phiên bản 3. 11

chạy(kết quả=Không có)

Thiết lập một vòng lặp sự kiện mới để chạy thử nghiệm, thu thập kết quả vào đối tượng được chuyển thành kết quả. Nếu kết quả bị bỏ qua hoặc

python -m unittest -h

2, một đối tượng kết quả tạm thời được tạo (bằng cách gọi phương thức

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

74) và được sử dụng. Đối tượng kết quả được trả về cho người gọi. Khi kết thúc kiểm tra, tất cả các tác vụ trong vòng lặp sự kiện đều bị hủy

Một ví dụ minh họa thứ tự

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

Sau khi chạy thử nghiệm,

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

74 sẽ chứa

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

lớp đơn vị kiểm tra. FunctionTestCase(testFunc , thiết lập=None, tearDown=None, description=None)

Lớp này thực hiện một phần của giao diện cho phép người chạy thử nghiệm thực hiện thử nghiệm, nhưng không cung cấp các phương thức mà mã thử nghiệm có thể sử dụng để kiểm tra và báo cáo lỗi. Điều này được sử dụng để tạo các trường hợp kiểm tra bằng cách sử dụng mã kiểm tra kế thừa, cho phép nó được tích hợp vào khung kiểm tra dựa trên

bí danh không dùng nữa

Vì lý do lịch sử, một số phương thức có một hoặc nhiều bí danh hiện không được dùng nữa. Bảng sau đây liệt kê các tên chính xác cùng với các bí danh không dùng nữa

Tên phương pháp
bí danh không dùng nữa
bí danh không dùng nữa
failUnlessEqual
khẳng địnhEquals
failIfEqual
khẳng địnhNotEquals
thất bạiTrừ khi
khẳng định_
failIf
thất bạiTrừ khi tăng
thất bạiTrừ khi Hầu như Bình đẳng
khẳng địnhAlmostEquals
failIfAlmostEqual
khẳng địnhNotAlmostEquals
khẳng địnhRegexpMatch
khẳng địnhNotRegexpMatches
khẳng địnhRaisesRegexp
Không dùng nữa kể từ phiên bản 3. 1. Bí danh fail* được liệt kê trong cột thứ hai không được dùng nữa.
Không dùng nữa kể từ phiên bản 3. 2. Các bí danh khẳng định* được liệt kê trong cột thứ ba không được dùng nữa.
Không dùng nữa kể từ phiên bản 3. 2. ______683 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

OK
38 đã được đổi tên thành và.
Không dùng nữa kể từ phiên bản 3. 5. 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

OK
87 không được dùng nữa để thay thế cho.

kiểm tra nhóm

lớp đơn vị kiểm tra. TestSuite(các bài kiểm tra=()

Lớp này đại diện cho một tập hợp các trường hợp thử nghiệm riêng lẻ và bộ thử nghiệm. Lớp trình bày giao diện cần thiết cho người chạy thử nghiệm để cho phép nó chạy như bất kỳ trường hợp thử nghiệm nào khác. Chạy một phiên bản cũng giống như lặp lại bộ phần mềm, chạy từng thử nghiệm riêng lẻ

Nếu các bài kiểm tra được cung cấp, nó phải là một lần lặp lại của các trường hợp kiểm tra riêng lẻ hoặc các bộ kiểm tra khác sẽ được sử dụng để xây dựng bộ ban đầu. Các phương pháp bổ sung được cung cấp để thêm các trường hợp và bộ thử nghiệm vào bộ sưu tập sau này

các đối tượng hoạt động giống như các đối tượng, ngoại trừ chúng không thực sự thực hiện kiểm thử. Thay vào đó, chúng được sử dụng để tổng hợp các bài kiểm tra thành các nhóm bài kiểm tra sẽ được chạy cùng nhau. Một số phương pháp bổ sung có sẵn để thêm thử nghiệm vào phiên bản

addTest(test)

Thêm một hoặc vào bộ

addTests(tests)

Thêm tất cả các thử nghiệm từ một phiên bản và phiên bản lặp lại vào bộ thử nghiệm này

Điều này tương đương với việc lặp lại các bài kiểm tra, gọi từng phần tử

chia sẻ các phương pháp sau đây với

chạy(kết quả)

Chạy các bài kiểm tra được liên kết với bộ phần mềm này, thu thập kết quả vào đối tượng kết quả kiểm tra được chuyển thành kết quả. Lưu ý rằng không giống như , yêu cầu đối tượng kết quả được chuyển vào

gỡ lỗi()

Chạy các bài kiểm tra được liên kết với bộ phần mềm này 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

countTestCases()

Trả về số lượng thử nghiệm được đại diện bởi đối tượng thử nghiệm này, bao gồm tất cả các thử nghiệm riêng lẻ và bộ con

__iter__()

Các bài kiểm tra được nhóm bởi a luôn được truy cập bằng cách lặp lại. Các lớp con có thể lười biếng cung cấp các bài kiểm tra bằng cách ghi đè. Lưu ý rằng phương pháp này có thể được gọi nhiều lần trên một bộ duy nhất (ví dụ: khi đếm các bài kiểm tra hoặc so sánh bằng nhau), vì vậy các bài kiểm tra được trả về bởi các lần lặp lại trước đó phải giống nhau cho mỗi lần lặp lại cuộc gọi. Sau đó, người gọi không nên dựa vào các bài kiểm tra được trả về bởi phương thức này trừ khi người gọi sử dụng một lớp con ghi đè

python -m unittest tests/test_something.py

12 để duy trì các tham chiếu kiểm tra

Đã thay đổi trong phiên bản 3. 2. Trong các phiên bản trước, các bài kiểm tra được truy cập trực tiếp thay vì thông qua phép lặp, vì vậy việc ghi đè không đủ để cung cấp các bài kiểm tra.

Đã thay đổi trong phiên bản 3. 4. Trong các phiên bản trước, các tham chiếu được giữ lại cho mỗi phiên bản sau. Các lớp con có thể khôi phục hành vi đó bằng cách ghi đè

python -m unittest tests/test_something.py

12.

Trong cách sử dụng điển hình của một đối tượng, phương thức này được gọi bởi một

python -m unittest tests/test_something.py

21 chứ không phải bởi khai thác thử nghiệm của người dùng cuối

Đang tải và chạy thử nghiệm

lớp đơn vị kiểm tra. Trình tải thử nghiệm

Lớp được sử dụng để tạo các bộ kiểm tra từ các lớp và mô-đun. Thông thường, không cần tạo một thể hiện của lớp này; . Tuy nhiên, việc sử dụng một lớp con hoặc cá thể cho phép tùy chỉnh một số thuộc tính có thể định cấu hình

các đối tượng có các thuộc tính sau

lỗi

Danh sách các lỗi không nghiêm trọng gặp phải khi tải các bài kiểm tra. Không được đặt lại bởi trình tải tại bất kỳ thời điểm nào. Các lỗi nghiêm trọng được báo hiệu bằng phương thức có liên quan, đưa ra một ngoại lệ cho người gọi. Các lỗi không nghiêm trọng cũng được chỉ ra bằng một thử nghiệm tổng hợp sẽ làm tăng lỗi ban đầu khi chạy

Mới trong phiên bản 3. 5

các đối tượng có các phương thức sau

loadTestsFromTestCase(testCaseClass)

Trả về một bộ gồm tất cả các trường hợp kiểm tra có trong _-dẫn xuất _ _ _ _ _ _ _ _ _ _ _

Một trường hợp thử nghiệm được tạo cho mỗi phương thức được đặt tên bởi. Theo mặc định, đây là những tên phương thức bắt đầu bằng

python -m unittest

0. Nếu không trả về phương thức nào, nhưng phương thức

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

59 được triển khai, thay vào đó, một trường hợp thử nghiệm duy nhất sẽ được tạo cho phương thức đó

loadTestsFromModule(mô-đun , mẫu=None)

Trả về một bộ tất cả các trường hợp thử nghiệm có trong mô-đun đã cho. Phương thức này tìm kiếm mô-đun cho các lớp bắt nguồn từ và tạo một thể hiện của lớp cho từng phương thức kiểm tra được xác định cho lớp

Ghi chú

Mặc dù việc sử dụng hệ thống phân cấp của các lớp -derived có thể thuận tiện trong việc chia sẻ các hàm trợ giúp và đồ đạc, nhưng việc xác định các phương thức kiểm tra trên các lớp cơ sở không nhằm mục đích khởi tạo trực tiếp sẽ không hoạt động tốt với phương thức này. Tuy nhiên, làm như vậy có thể hữu ích khi các đồ đạc khác nhau và được xác định trong các lớp con.

Nếu một mô-đun cung cấp chức năng

python -m unittest tests/test_something.py

35, nó sẽ được gọi để tải các bài kiểm tra. Điều này cho phép các mô-đun tùy chỉnh tải thử nghiệm. Đây là. Đối số mẫu được truyền làm đối số thứ ba cho

python -m unittest tests/test_something.py

Đã thay đổi trong phiên bản 3. 2. Đã thêm hỗ trợ cho

python -m unittest tests/test_something.py

35.

Đã thay đổi trong phiên bản 3. 5. Đối số mặc định use_load_tests không có giấy tờ và không chính thức không được chấp nhận và bỏ qua, mặc dù nó vẫn được chấp nhận để tương thích ngược. Phương thức hiện cũng chấp nhận mẫu đối số chỉ từ khóa được chuyển đến

python -m unittest tests/test_something.py

35 làm đối số thứ ba.

loadTestsFromName(tên , mô-đun=None)

Trả về một bộ tất cả các trường hợp kiểm tra được cung cấp một trình xác định chuỗi

Tên chỉ định là một "tên chấm" có thể phân giải thành một mô-đun, một lớp trường hợp thử nghiệm, một phương thức thử nghiệm trong một lớp trường hợp thử nghiệm, một thể hiện hoặc một đối tượng có thể gọi được trả về một hoặc một thể hiện. Những kiểm tra này được áp dụng theo thứ tự được liệt kê ở đây;

Ví dụ: nếu bạn có một mô-đun

python -m unittest tests/test_something.py

42 chứa lớp dẫn xuất _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ a. Sử dụng công cụ xác định

python -m unittest tests/test_something.py

49 sẽ khiến nó trả về một bộ thử nghiệm sẽ chỉ chạy phương thức thử nghiệm

python -m unittest tests/test_something.py

46. Trình xác định có thể tham chiếu đến các mô-đun và gói chưa được nhập;

Phương thức tùy chọn giải quyết tên liên quan đến mô-đun đã cho

Đã thay đổi trong phiên bản 3. 5. Nếu một hoặc xảy ra trong khi duyệt tên thì một thử nghiệm tổng hợp phát sinh lỗi đó khi chạy sẽ được trả về. Những lỗi này được bao gồm trong các lỗi được tích lũy bởi bản thân. lỗi.

loadTestsFromNames(tên , mô-đun=None)

Tương tự như , nhưng có một chuỗi các tên chứ không phải một tên duy nhất. Giá trị trả về là một bộ thử nghiệm hỗ trợ tất cả các thử nghiệm được xác định cho mỗi tên

getTestCaseNames(testCaseClass)

Trả về một chuỗi các tên phương thức được sắp xếp tìm thấy trong testCaseClass;

khám phá(start_dir , mẫu='test*.py' , top_level_dir=Không có)

Tìm tất cả các mô-đun thử nghiệm bằng cách đệ quy vào các thư mục con từ thư mục bắt đầu đã chỉ định và trả về một đối tượng TestSuite chứa chúng. Chỉ các tệp kiểm tra phù hợp với mẫu mới được tải. (Sử dụng khớp mẫu kiểu vỏ. ) Chỉ những tên mô-đun có thể nhập được (i. e. là số nhận dạng Python hợp lệ) sẽ được tải

Tất cả các mô-đun thử nghiệm phải được nhập từ cấp cao nhất của dự án. Nếu thư mục bắt đầu không phải là thư mục cấp cao nhất thì thư mục cấp cao nhất phải được chỉ định riêng

Nếu nhập một mô-đun không thành công, chẳng hạn như do lỗi cú pháp, thì lỗi này sẽ được ghi lại dưới dạng một lỗi duy nhất và quá trình khám phá sẽ tiếp tục. Nếu lỗi nhập là do được nâng lên, nó sẽ được ghi là bỏ qua thay vì lỗi

Nếu một gói (một thư mục chứa tệp có tên

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()

89) được tìm thấy, gói đó sẽ được kiểm tra hàm

python -m unittest tests/test_something.py

35. Nếu điều này tồn tại thì nó sẽ được gọi là

python -m unittest tests/test_something.py

58. Khám phá thử nghiệm cẩn thận để đảm bảo rằng một gói chỉ được kiểm tra các thử nghiệm một lần trong khi gọi, ngay cả khi hàm load_tests tự gọi

python -m unittest tests/test_something.py

Nếu

python -m unittest tests/test_something.py

35 tồn tại thì khám phá không lặp lại trong gói,

python -m unittest tests/test_something.py

35 chịu trách nhiệm tải tất cả các bài kiểm tra trong gói

Mẫu được cố tình không lưu trữ dưới dạng thuộc tính trình tải để các gói có thể tiếp tục tự khám phá. top_level_dir được lưu trữ nên

python -m unittest tests/test_something.py

35 không cần chuyển đối số này vào

python -m unittest tests/test_something.py

start_dir có thể là tên mô-đun chấm cũng như thư mục

Mới trong phiên bản 3. 2

Đã thay đổi trong phiên bản 3. 4. Các mô-đun tăng khi nhập được ghi lại là bỏ qua, không phải lỗi.

Đã thay đổi trong phiên bản 3. 4. start_dir có thể là một.

Đã thay đổi trong phiên bản 3. 4. Các đường dẫn được sắp xếp trước khi được nhập để thứ tự thực thi giống nhau ngay cả khi thứ tự của hệ thống tệp cơ bản không phụ thuộc vào tên tệp.

Đã thay đổi trong phiên bản 3. 5. Các gói đã tìm thấy hiện được kiểm tra cho

python -m unittest tests/test_something.py

35 bất kể đường dẫn của chúng có khớp với mẫu hay không, vì tên gói không thể khớp với mẫu mặc định.

Đã thay đổi trong phiên bản 3. 11. start_dir không thể là một. Nó đã bị hỏng kể từ Python 3. 7 và Trăn 3. 11 chính thức loại bỏ nó.

Các thuộc tính sau của a có thể được cấu hình bằng cách phân lớp hoặc gán trên một phiên bản

testMethodPrefix

Chuỗi đưa ra tiền tố của tên phương thức sẽ được hiểu là phương thức thử nghiệm. Giá trị mặc định là

python -m unittest tests/test_something.py

Điều này ảnh hưởng và tất cả các phương pháp

python -m unittest tests/test_something.py

sortTestMethodsSử dụng

Hàm được sử dụng để so sánh tên phương thức khi sắp xếp chúng và tất cả các phương thức

python -m unittest tests/test_something.py

bộLớp học

Đối tượng có thể gọi được xây dựng bộ thử nghiệm từ danh sách các thử nghiệm. Không cần phương thức trên đối tượng kết quả. Giá trị mặc định là lớp

Điều này ảnh hưởng đến tất cả các phương pháp

python -m unittest tests/test_something.py

tên thử nghiệmMô hình

Danh sách các mẫu tên thử nghiệm ký tự đại diện kiểu hệ vỏ Unix mà các phương thức thử nghiệm phải khớp để được đưa vào bộ thử nghiệm (xem tùy chọn

python -m unittest

Nếu thuộc tính này không phải là

python -m unittest -h

2 (mặc định), thì tất cả các phương thức kiểm tra được đưa vào bộ kiểm tra phải khớp với một trong các mẫu trong danh sách này. Lưu ý rằng các kết quả khớp luôn được thực hiện bằng cách sử dụng , do đó, không giống như các mẫu được chuyển đến tùy chọn

python -m unittest

9, các mẫu chuỗi con đơn giản sẽ phải được chuyển đổi bằng ký tự đại diện

python -m unittest -h

Điều này ảnh hưởng đến tất cả các phương pháp

python -m unittest tests/test_something.py

Mới trong phiên bản 3. 7

lớp đơn vị kiểm tra. Kết quả kiểm tra

Lớp này được sử dụng để biên dịch thông tin về bài kiểm tra nào thành công và bài kiểm tra nào thất bại

Một đối tượng lưu trữ kết quả của một tập hợp các bài kiểm tra. Các lớp và đảm bảo rằng kết quả được ghi lại đúng cách;

Các khung thử nghiệm được xây dựng dựa trên có thể muốn truy cập vào đối tượng được tạo bằng cách chạy một bộ thử nghiệm cho mục đích báo cáo;

các phiên bản có các thuộc tính sau đây sẽ được quan tâm khi kiểm tra kết quả chạy một bộ thử nghiệm

lỗi

Một danh sách chứa 2 bộ phiên bản và chuỗi chứa truy nguyên được định dạng. Mỗi bộ đại diện cho một bài kiểm tra đưa ra một ngoại lệ không mong muốn

thất bại

Một danh sách chứa 2 bộ phiên bản và chuỗi chứa truy nguyên được định dạng. Mỗi bộ dữ liệu đại diện cho một thử nghiệm trong đó lỗi được báo hiệu rõ ràng bằng cách sử dụng các phương thức

python -m unittest tests/test_something.py

bỏ qua

Một danh sách chứa 2 bộ phiên bản và chuỗi chứa lý do bỏ qua bài kiểm tra

Mới trong phiên bản 3. 1

thất bại dự kiến

Một danh sách chứa 2 bộ phiên bản và chuỗi chứa truy nguyên được định dạng. Mỗi bộ dữ liệu đại diện cho một lỗi hoặc lỗi dự kiến của trường hợp thử nghiệm

thành công ngoài mong đợi

Một danh sách chứa các phiên bản được đánh dấu là lỗi dự kiến, nhưng đã thành công

nên dừng lại

Đặt thành

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

13 khi quá trình thực hiện kiểm tra sẽ dừng lại

kiểm traChạy

Tổng số bài kiểm tra chạy cho đến nay

đệm

Nếu được đặt thành true,

python -m unittest tests/test_something.py

96 và

python -m unittest tests/test_something.py

97 sẽ được đệm ở giữa và được gọi. Đầu ra được thu thập sẽ chỉ được lặp lại trên

python -m unittest tests/test_something.py

96 và

python -m unittest tests/test_something.py

97 thực nếu thử nghiệm không thành công hoặc có lỗi. Bất kỳ đầu ra nào cũng được đính kèm với thông báo lỗi / lỗi

Mới trong phiên bản 3. 2

thất bại

Nếu được đặt thành true sẽ được gọi trong lỗi hoặc lỗi đầu tiên, tạm dừng quá trình chạy thử

Mới trong phiên bản 3. 2

tb_locals

Nếu được đặt thành true thì các biến cục bộ sẽ được hiển thị trong truy nguyên

Mới trong phiên bản 3. 5

wasSuccessful()

Trả lại

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

13 nếu tất cả các bài kiểm tra chạy cho đến nay đã vượt qua, nếu không thì trả lại

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

Đã thay đổi trong phiên bản 3. 4. Trả về

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

14 nếu có bất kỳ bài kiểm tra nào được đánh dấu bằng bộ trang trí.

dừng()

Phương pháp này có thể được gọi để báo hiệu rằng bộ kiểm tra đang chạy phải bị hủy bỏ bằng cách đặt thuộc tính thành

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

13. Các đối tượng

python -m unittest tests/test_something.py

21 phải tôn trọng cờ này và quay lại mà không chạy bất kỳ thử nghiệm bổ sung nào

Ví dụ: tính năng này được lớp sử dụng để dừng khung kiểm tra khi người dùng báo hiệu ngắt từ bàn phím. Các công cụ tương tác cung cấp triển khai

python -m unittest tests/test_something.py

21 có thể sử dụng điều này theo cách tương tự

Các phương thức sau của lớp được sử dụng để duy trì cấu trúc dữ liệu nội bộ và có thể được mở rộng trong các lớp con để hỗ trợ các yêu cầu báo cáo bổ sung. Điều này đặc biệt hữu ích trong việc xây dựng các công cụ hỗ trợ báo cáo tương tác trong khi chạy thử nghiệm

startTest(test)

Được gọi khi test case chuẩn bị chạy

stopTest(test)

Được gọi sau khi test case test đã được thực thi, bất kể kết quả như thế nào

startTestRun()

Được gọi một lần trước khi bất kỳ kiểm tra nào được thực hiện

Mới trong phiên bản 3. 1

stopTestRun()

Được gọi một lần sau khi tất cả các bài kiểm tra được thực hiện

Mới trong phiên bản 3. 1

addError(test , err)

Được gọi khi kiểm tra trường hợp thử nghiệm phát sinh một ngoại lệ không mong muốn. err là một bộ dữ liệu có dạng được trả về bởi.

python -m unittest -v test_module

Việc triển khai mặc định nối thêm một bộ

python -m unittest -v test_module

16 vào thuộc tính của cá thể, trong đó formatted_err là một truy nguyên được định dạng xuất phát từ err

addFailure(kiểm tra , err)

Được gọi khi kiểm tra trường hợp thử nghiệm báo hiệu lỗi. err là một bộ dữ liệu có dạng được trả về bởi.

python -m unittest -v test_module

Việc triển khai mặc định nối thêm một bộ

python -m unittest -v test_module

16 vào thuộc tính của cá thể, trong đó formatted_err là một truy nguyên được định dạng xuất phát từ err

addSuccess(kiểm tra)

Được gọi khi test case test thành công

Việc thực hiện mặc định không có gì

addSkip(kiểm tra , lý do)

Được gọi khi test case test bị bỏ qua. lý do là lý do bài kiểm tra đưa ra để bỏ qua

Việc triển khai mặc định nối thêm một tuple

python -m unittest -v test_module

22 vào thuộc tính của cá thể

addExpectedFailure(kiểm tra , lỗi)

Được gọi khi kiểm tra trường hợp thử nghiệm không thành công hoặc có lỗi, nhưng đã được đánh dấu bằng trình trang trí

Việc triển khai mặc định nối thêm một bộ

python -m unittest -v test_module

16 vào thuộc tính của cá thể, trong đó formatted_err là một truy nguyên được định dạng xuất phát từ err

addUnexpectedSuccess(kiểm tra)

Được gọi khi kiểm tra trường hợp thử nghiệm được đánh dấu bằng trình trang trí, nhưng đã thành công

Việc triển khai mặc định nối thêm thử nghiệm vào thuộc tính của cá thể

addSubTest(test , subtest, outcome)

Được gọi khi một subtest kết thúc. test là trường hợp thử nghiệm tương ứng với phương pháp thử nghiệm. subtest là một phiên bản tùy chỉnh mô tả subtest

Nếu kết quả là , bài kiểm tra phụ đã thành công. Mặt khác, nó không thành công với một ngoại lệ trong đó kết quả là một bộ có dạng được trả về bởi.

python -m unittest -v test_module

Việc triển khai mặc định không làm gì khi kết quả thành công và ghi lại các lỗi kiểm tra phụ như các lỗi thông thường

Mới trong phiên bản 3. 4

lớp đơn vị kiểm tra. TextTestResult(luồng , mô tả, verbosity)

Một triển khai cụ thể được sử dụng bởi

Mới trong phiên bản 3. 2. Lớp này trước đây có tên là

python -m unittest -v test_module

35. Tên cũ vẫn tồn tại dưới dạng bí danh nhưng không được dùng nữa.

đơn vị nhỏ nhất. defaultTestLoader

Thể hiện của lớp dự định được chia sẻ. Nếu không cần tùy chỉnh, phiên bản này có thể được sử dụng thay vì liên tục tạo các phiên bản mới

lớp đơn vị kiểm tra. TextTestRunner(luồng=Không có, descriptions=True, verbosity=1, failfast=False, buffer=False, resultclass=None, warnings=None, *, tb_locals=False)

Một triển khai trình chạy thử nghiệm cơ bản xuất kết quả thành luồng. Nếu luồng là

python -m unittest -h

2, mặc định, được sử dụng làm luồng đầu ra. Lớp này có một vài tham số có thể cấu hình, nhưng về cơ bản thì rất đơn giản. Các ứng dụng đồ họa chạy bộ thử nghiệm sẽ cung cấp các triển khai thay thế. Việc triển khai như vậy phải chấp nhận

python -m unittest -v test_module

40 làm giao diện để xây dựng các trình chạy thay đổi khi các tính năng được thêm vào unittest

Theo mặc định, trình chạy này hiển thị , và ngay cả khi chúng. Các cảnh báo không dùng nữa gây ra bởi cũng là trường hợp đặc biệt và khi các bộ lọc cảnh báo là

python -m unittest -v test_module

45 hoặc

python -m unittest -v test_module

46, chúng sẽ chỉ xuất hiện một lần cho mỗi mô-đun, để tránh có quá nhiều thông báo cảnh báo. Hành vi này có thể bị ghi đè bằng cách sử dụng các tùy chọn

python -m unittest -v test_module

47 hoặc

python -m unittest -v test_module

48 của Python (xem phần ) và để lại cảnh báo cho

python -m unittest -h

Đã thay đổi trong phiên bản 3. 2. Đã thêm đối số

python -m unittest -v test_module

50.

Đã thay đổi trong phiên bản 3. 2. Luồng mặc định được đặt thành thời điểm khởi tạo thay vì thời điểm nhập.

Đã thay đổi trong phiên bản 3. 5. Đã thêm thông số tb_locals.

_makeResult()

Phương thức này trả về thể hiện của

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

37 được sử dụng bởi. Nó không có ý định được gọi trực tiếp, nhưng có thể được ghi đè trong các lớp con để cung cấp một

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

37 tùy chỉnh

python -m unittest -v test_module

55 khởi tạo lớp hoặc có thể gọi được truyền trong hàm tạo

python -m unittest -v test_module

11 dưới dạng đối số

python -m unittest -v test_module

57. Nó mặc định nếu không có

python -m unittest -v test_module

57 được cung cấp. Lớp kết quả được khởi tạo với các đối số sau

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

chạy(kiểm tra)

Phương thức này là giao diện công khai chính của

python -m unittest -v test_module

11. Phương thức này lấy một hoặc thể hiện. A được tạo bằng cách gọi và (các) bài kiểm tra được chạy và kết quả được in ra thiết bị xuất chuẩn

đơn vị nhất. chính(mô-đun=' . defaultTestLoader, defaultTest=None, argv=None, testRunner=None, testLoader=unittest.defaultTestLoader , thoát=True, verbosity=1, failfast=None, catchbreak=None, buffer=None, warnings=None)

Một chương trình dòng lệnh tải một tập hợp các bài kiểm tra từ mô-đun và chạy chúng; . Cách sử dụng đơn giản nhất cho hàm này là thêm dòng sau vào cuối tập lệnh kiểm tra

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

Bạn có thể chạy thử nghiệm với thông tin chi tiết hơn bằng cách chuyển vào đối số chi tiết

python -m unittest tests/test_something.py

Đối số defaultTest là tên của một thử nghiệm đơn lẻ hoặc một tên thử nghiệm lặp lại để chạy nếu không có tên thử nghiệm nào được chỉ định qua argv. Nếu không được chỉ định hoặc

python -m unittest -h

2 và không có tên kiểm tra nào được cung cấp qua argv, tất cả các kiểm tra được tìm thấy trong mô-đun sẽ được chạy

Đối số argv có thể là danh sách các tùy chọn được chuyển đến chương trình, với phần tử đầu tiên là tên chương trình. Nếu không được chỉ định hoặc

python -m unittest -h

2, các giá trị của được sử dụng

Đối số testRunner có thể là một lớp người chạy thử nghiệm hoặc một thể hiện đã được tạo của nó. Theo mặc định, các cuộc gọi

python -m unittest -v test_module

68 có mã thoát cho biết thành công hay thất bại của quá trình chạy thử nghiệm

Đối số testLoader phải là một thể hiện và mặc định là

python -m unittest -v test_module

68 hỗ trợ được sử dụng từ trình thông dịch tương tác bằng cách chuyển vào đối số

python -m unittest -v test_module

73. Điều này hiển thị kết quả trên đầu ra tiêu chuẩn mà không cần gọi

python -m unittest tests/test_something.py

Các tham số failfast, catchbreak và buffer có tác dụng tương tự như tên gọi cùng tên

Đối số cảnh báo chỉ định đối số sẽ được sử dụng trong khi chạy thử nghiệm. Nếu nó không được chỉ định, nó sẽ vẫn là

python -m unittest -h

2 nếu tùy chọn

python -m unittest -v test_module

76 được chuyển cho python (xem phần ), nếu không, nó sẽ được đặt thành

python -m unittest -v test_module

Gọi

python -m unittest -v test_module

68 thực sự trả về một thể hiện của lớp

python -m unittest -v test_module

79. Điều này lưu trữ kết quả của các lần chạy thử dưới dạng thuộc tính

python -m unittest -v test_module

Đã thay đổi trong phiên bản 3. 1. Tham số thoát đã được thêm vào.

Đã thay đổi trong phiên bản 3. 2. Các tham số độ chi tiết, failfast, catchbreak, bộ đệm và cảnh báo đã được thêm vào.

Đã thay đổi trong phiên bản 3. 4. Tham số defaultTest đã được thay đổi để cũng chấp nhận tên thử nghiệm có thể lặp lại.

giao thức load_tests

Mới trong phiên bản 3. 2

Các mô-đun hoặc gói có thể tùy chỉnh cách các bài kiểm tra được tải từ chúng trong quá trình chạy thử nghiệm bình thường hoặc phát hiện thử nghiệm bằng cách triển khai một chức năng có tên là

python -m unittest tests/test_something.py

Nếu một mô-đun thử nghiệm định nghĩa

python -m unittest tests/test_something.py

35, nó sẽ được gọi bởi với các đối số sau

python -m unittest tests/test_something.py

nơi mẫu được truyền thẳng từ

python -m unittest -v test_module

84. Nó mặc định là

python -m unittest -h

Nó sẽ trả lại một

trình tải là ví dụ thực hiện tải. standard_tests là các bài kiểm tra sẽ được tải theo mặc định từ mô-đun. Thông thường, các mô-đun thử nghiệm chỉ muốn thêm hoặc xóa các thử nghiệm khỏi bộ thử nghiệm tiêu chuẩn. Đối số thứ ba được sử dụng khi tải các gói như một phần của khám phá thử nghiệm

Một hàm

python -m unittest tests/test_something.py

35 điển hình tải các bài kiểm tra từ một nhóm lớp cụ thể có thể giống như

python -m unittest tests/test_something.py

Nếu khám phá được bắt đầu trong một thư mục chứa gói, từ dòng lệnh hoặc bằng cách gọi , thì gói

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()

89 sẽ được kiểm tra cho

python -m unittest tests/test_something.py

35. Nếu chức năng đó không tồn tại, khám phá sẽ lặp lại trong gói như thể nó chỉ là một thư mục khác. Mặt khác, việc khám phá các bài kiểm tra của gói sẽ bị bỏ lại cho đến khi

python -m unittest tests/test_something.py

35 được gọi với các đối số sau

python -m unittest tests/test_something.py

Điều này sẽ trả về một đại diện cho tất cả các bài kiểm tra từ gói. (

python -m unittest -v test_module

95 sẽ chỉ chứa các bài kiểm tra được thu thập từ

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()

89. )

Vì mẫu được chuyển vào

python -m unittest tests/test_something.py

35 nên gói được tự do tiếp tục (và có khả năng sửa đổi) khám phá thử nghiệm. Chức năng 'không làm gì'

python -m unittest tests/test_something.py

35 cho gói thử nghiệm sẽ như thế nào

python -m unittest tests/test_something.py

Đã thay đổi trong phiên bản 3. 5. Discovery không còn kiểm tra tên gói để tìm mẫu khớp do không thể có tên gói khớp với mẫu mặc định.

Đồ đạc lớp và mô-đun

Đồ đạc cấp độ lớp và mô-đun được triển khai trong. Khi bộ kiểm tra gặp một bài kiểm tra từ một lớp mới thì

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

49 từ lớp trước đó (nếu có) được gọi, theo sau là

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

48 từ lớp mới

Tương tự, nếu thử nghiệm từ một mô-đun khác với thử nghiệm trước đó thì

python -m unittest

02 từ mô-đun trước đó sẽ được chạy, tiếp theo là

python -m unittest

03 từ mô-đun mới

Sau khi tất cả các thử nghiệm đã chạy,

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

70 và

python -m unittest

02 cuối cùng sẽ được chạy

Lưu ý rằng các thiết bị cố định được chia sẻ không hoạt động tốt với các tính năng [tiềm năng] như song song hóa thử nghiệm và chúng phá vỡ sự cô lập thử nghiệm. Chúng nên được sử dụng cẩn thận

Thứ tự mặc định của các bài kiểm tra được tạo bởi bộ tải kiểm tra unittest là nhóm tất cả các bài kiểm tra từ cùng các mô-đun và lớp lại với nhau. Điều này sẽ dẫn đến việc

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

68 /

python -m unittest

03 (v.v.) được gọi chính xác một lần cho mỗi lớp và mô-đun. Nếu bạn sắp xếp thứ tự ngẫu nhiên, để các bài kiểm tra từ các mô-đun và lớp khác nhau liền kề nhau, thì các hàm cố định được chia sẻ này có thể được gọi nhiều lần trong một lần chạy thử nghiệm

Đồ đạc dùng chung không nhằm mục đích hoạt động với các bộ có thứ tự không chuẩn. Một

python -m unittest

08 vẫn tồn tại đối với các khung không muốn hỗ trợ đồ đạc được chia sẻ

Nếu có bất kỳ ngoại lệ nào được đưa ra trong một trong các chức năng cố định được chia sẻ, thử nghiệm sẽ được báo cáo là lỗi. Bởi vì không có phiên bản thử nghiệm tương ứng, một đối tượng

python -m unittest

09 (có giao diện giống như a ) được tạo để biểu thị lỗi. Nếu bạn chỉ đang sử dụng trình chạy thử nghiệm unittest tiêu chuẩn thì chi tiết này không thành vấn đề, nhưng nếu bạn là tác giả khung thì điều đó có thể liên quan

setUpClass vàearDownClass

Chúng phải được thực hiện như các phương thức lớp

python -m unittest tests/test_something.py

Nếu bạn muốn gọi

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

68 và

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

70 trên các lớp cơ sở thì bạn phải tự gọi chúng. Việc triển khai trong trống

Nếu một ngoại lệ được đưa ra trong một

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

68 thì các bài kiểm tra trong lớp sẽ không chạy và

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

70 không chạy. Các lớp bị bỏ qua sẽ không chạy

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

68 hoặc

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

70. Nếu ngoại lệ là ngoại lệ thì lớp sẽ được báo cáo là đã bị bỏ qua thay vì lỗi

setUpModule vàearDownModule

Chúng nên được thực hiện như các chức năng

python -m unittest tests/test_something.py

Nếu một ngoại lệ được đưa ra trong

python -m unittest

03 thì không có thử nghiệm nào trong mô-đun sẽ được chạy và

python -m unittest

02 sẽ không được chạy. Nếu ngoại lệ là ngoại lệ thì mô-đun sẽ được báo cáo là đã bị bỏ qua thay vì lỗi

Để thêm mã dọn dẹp phải chạy ngay cả trong trường hợp ngoại lệ, hãy sử dụng

python -m unittest

đơn vị nhỏ nhất. addModuleCleanup(chức năng , /, *args, **kwargs)

Thêm một chức năng được gọi sau

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

51 để dọn sạch tài nguyên được sử dụng trong lớp kiểm tra. Các chức năng sẽ được gọi theo thứ tự ngược lại với thứ tự chúng được thêm vào (LIFO). Chúng được gọi với bất kỳ đối số và đối số từ khóa nào được truyền vào khi chúng được thêm vào

Nếu

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

50 không thành công, nghĩa là

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

51 không được gọi, thì mọi chức năng dọn dẹp được thêm vào sẽ vẫn được gọi

Mới trong phiên bản 3. 8

phương thức lớp đơn vị kiểm tra. enterModuleContext(cm)

Nhập được cung cấp. Nếu thành công, hãy thêm phương thức của nó làm hàm dọn dẹp và trả về kết quả của phương thức

Mới trong phiên bản 3. 11

đơn vị nhất. doModuleCleanups()

Hàm này được gọi vô điều kiện sau

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

51 hoặc sau

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

50 nếu

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

50 đưa ra một ngoại lệ

Nó chịu trách nhiệm gọi tất cả các chức năng dọn dẹp được thêm bởi. Nếu bạn cần gọi các chức năng dọn dẹp trước

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

51 thì bạn có thể tự gọi

bật từng phương thức ra khỏi ngăn xếp của các hàm dọn dẹp, vì vậy nó có thể được gọi bất cứ lúc nào

Mới trong phiên bản 3. 8

Xử lý tín hiệu

Mới trong phiên bản 3. 2

Tùy chọn dòng lệnh cho unittest, cùng với tham số

python -m unittest

38 cho , cung cấp khả năng xử lý control-C thân thiện hơn trong quá trình chạy thử. Với hành vi bắt ngắt được kích hoạt, control-C sẽ cho phép hoàn thành kiểm tra hiện đang chạy và quá trình chạy kiểm tra sau đó sẽ kết thúc và báo cáo tất cả các kết quả cho đến nay. Control-c thứ hai sẽ tăng a theo cách thông thường

Trình xử lý tín hiệu xử lý control-c cố gắng duy trì khả năng tương thích với mã hoặc kiểm tra cài đặt trình xử lý của riêng chúng. Nếu trình xử lý

python -m unittest tests/test_something.py

9 được gọi nhưng không phải là trình xử lý đã cài đặt, tôi. e. nó đã được thay thế bởi hệ thống đang thử nghiệm và được ủy quyền, sau đó nó gọi trình xử lý mặc định. Đây thường sẽ là hành vi được mong đợi bằng mã thay thế trình xử lý đã cài đặt và ủy quyền cho nó. Đối với các thử nghiệm riêng lẻ cần xử lý

python -m unittest tests/test_something.py

9 control-c bị vô hiệu hóa, có thể sử dụng trình trang trí

Có một vài chức năng tiện ích cho các tác giả khung để kích hoạt chức năng xử lý control-c trong các khung kiểm tra

đơn vị nhỏ nhất. installHandler()

Cài đặt trình xử lý control-c. Khi nhận được a (thường là để phản hồi lại việc người dùng nhấn control-c), tất cả các kết quả đã đăng ký đã được gọi

đơn vị nhất. registerResult(kết quả)

Đăng ký một đối tượng để xử lý control-c. Đăng ký một kết quả lưu trữ một tham chiếu yếu đến nó, vì vậy nó không ngăn kết quả bị thu gom rác

Việc đăng ký một đối tượng không có tác dụng phụ nếu tính năng xử lý control-c không được bật, vì vậy các khung kiểm tra có thể đăng ký vô điều kiện tất cả các kết quả mà chúng tạo ra bất kể việc xử lý có được bật hay không

đơn vị nhỏ nhất. removeResult(kết quả)

Xóa kết quả đã đăng ký. Khi một kết quả đã bị xóa thì sẽ không còn được gọi trên đối tượng kết quả đó để phản hồi điều khiển-c

đơn vị nhất. removeHandler(chức năng=Không có)

Khi được gọi mà không có đối số, hàm này sẽ xóa trình xử lý control-c nếu nó đã được cài đặt. Chức năng này cũng có thể được sử dụng làm công cụ trang trí thử nghiệm để tạm thời xóa trình xử lý trong khi thử nghiệm đang được thực thi

programming python

Kiểm tra Python với pytest pdf GitHub

Ví dụ cơ bản

Giao diện dòng lệnh

Tùy chọn dòng lệnh

khám phá thử nghiệm

Tổ chức mã kiểm tra

Sử dụng lại mã kiểm tra cũ

Bỏ qua các bài kiểm tra và thất bại dự kiến

Phân biệt các lần lặp kiểm tra bằng cách sử dụng phép trừ

Các lớp và chức năng

trường hợp thử nghiệm

bí danh không dùng nữa

kiểm tra nhóm

Đang tải và chạy thử nghiệm

giao thức load_tests

Đồ đạc lớp và mô-đun

setUpClass vàearDownClass

setUpModule vàearDownModule

Xử lý tín hiệu

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội