programming python

Khóa học kiểm thử phần mềm python

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

Để đạ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 đã gặp 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ài kiểm tra.

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. Thí 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

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

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ài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề