Pytest - Hướng dẫn nhanh

Pytest là một khung kiểm tra dựa trên python, được sử dụng để viết và thực thi các mã kiểm tra. Trong các dịch vụ REST ngày nay, pytest chủ yếu được sử dụng để kiểm tra API mặc dù chúng ta có thể sử dụng pytest để viết các bài kiểm tra từ đơn giản đến phức tạp, tức là chúng ta có thể viết mã để kiểm tra API, cơ sở dữ liệu, giao diện người dùng, v.v.

Ưu điểm của Pytest

Ưu điểm của Pytest như sau:

• Pytest có thể chạy nhiều thử nghiệm song song, điều này giúp giảm thời gian thực thi của bộ thử nghiệm.

• Pytest có cách riêng để phát hiện tệp kiểm tra và kiểm tra các chức năng tự động, nếu không được đề cập rõ ràng.

• Pytest cho phép chúng ta bỏ qua một tập hợp con của các bài kiểm tra trong quá trình thực thi.

• Pytest cho phép chúng tôi chạy một tập hợp con của toàn bộ bộ thử nghiệm.

• Pytest là mã nguồn mở và miễn phí.

• Bởi vì cú pháp đơn giản của nó, pytest rất dễ bắt đầu.

Trong hướng dẫn này, chúng tôi sẽ giải thích các nguyên tắc cơ bản về pytest với các chương trình mẫu.

Trong chương này, chúng ta sẽ học cách cài đặt pytest.

Để bắt đầu cài đặt, hãy thực hiện lệnh sau:

pip install pytest == 2.9.1

Chúng tôi có thể cài đặt bất kỳ phiên bản nào của pytest. Ở đây, 2.9.1 là phiên bản chúng tôi đang cài đặt.

Để cài đặt phiên bản mới nhất của pytest, hãy thực hiện lệnh sau:

pip install pytest

Xác nhận cài đặt bằng lệnh sau để hiển thị phần trợ giúp của pytest.

pytest -h

Chạy pytest mà không đề cập đến tên tệp sẽ chạy tất cả các tệp có định dạng test_*.py hoặc là *_test.pytrong thư mục hiện tại và các thư mục con. Pytest tự động xác định các tệp đó là tệp thử nghiệm. Chúng tôican làm cho pytest chạy các tên tệp khác bằng cách đề cập rõ ràng đến chúng.

Pytest yêu cầu tên hàm kiểm tra bắt đầu bằng test. Tên hàm không có định dạngtest*không được coi là hàm kiểm tra bởi pytest. Chúng tôicannot rõ ràng làm cho pytest xem xét bất kỳ hàm nào không bắt đầu bằng test như một chức năng kiểm tra.

Chúng tôi sẽ hiểu việc thực hiện các bài kiểm tra trong các chương tiếp theo của chúng tôi.

Bây giờ, chúng ta sẽ bắt đầu với chương trình pytest đầu tiên của mình. Trước tiên, chúng tôi sẽ tạo một thư mục và do đó, tạo các tệp thử nghiệm của chúng tôi trong thư mục.

Hãy để chúng tôi làm theo các bước được hiển thị bên dưới -

• Tạo một thư mục mới có tên automation và điều hướng vào thư mục trong dòng lệnh của bạn.

• Tạo một tệp có tên test_square.py và thêm mã bên dưới vào tệp đó.

import math

def test_sqrt():
   num = 25
   assert math.sqrt(num) == 5

def testsquare():
   num = 7
   assert 7*7 == 40

def tesequality():
   assert 10 == 11

Chạy thử nghiệm bằng lệnh sau:

pytest

Lệnh trên sẽ tạo ra kết quả sau:

test_square.py .F
============================================== FAILURES 
==============================================
______________________________________________ testsquare 
_____________________________________________
   def testsquare():
   num=7
>  assert 7*7 == 40
E  assert (7 * 7) == 40
test_square.py:9: AssertionError
================================= 1 failed, 1 passed in 0.06 seconds 
=================================

Xem dòng đầu tiên của kết quả. Nó hiển thị tên tệp và kết quả. F đại diện cho một thử nghiệm thất bại và dấu chấm (.) Thể hiện một thử nghiệm thành công.

Dưới đó, chúng ta có thể xem chi tiết các bài kiểm tra thất bại. Nó sẽ hiển thị câu lệnh nào mà bài kiểm tra không thành công. Trong ví dụ của chúng tôi, 7 * 7 được so sánh ngang bằng với 40, điều này là sai. Cuối cùng, chúng ta có thể thấy tóm tắt thực thi thử nghiệm, 1 không thành công và 1 đạt.

Hàm tesequality không được thực thi vì pytest sẽ không coi nó là một phép thử vì tên của nó không có định dạng test*.

Bây giờ, hãy thực hiện lệnh dưới đây và xem lại kết quả -

pytest -v

-v làm tăng tính dài dòng.

test_square.py::test_sqrt PASSED
test_square.py::testsquare FAILED
============================================== FAILURES 
==============================================
_____________________________________________ testsquare 
_____________________________________________
   def testsquare():
   num = 7
>  assert 7*7 == 40
E  assert (7 * 7) == 40
test_square.py:9: AssertionError
================================= 1 failed, 1 passed in 0.04 seconds 
=================================

Bây giờ kết quả được giải thích rõ hơn về bài kiểm tra không thành công và bài kiểm tra đã vượt qua.

Note - Lệnh pytest sẽ thực thi tất cả các tệp có định dạng test_* hoặc là *_test trong thư mục hiện tại và các thư mục con.

Trong chương này, chúng ta sẽ học cách thực thi một tệp thử nghiệm và nhiều tệp thử nghiệm. Chúng tôi đã có một tệp thử nghiệmtest_square.pytạo. Tạo một tệp thử nghiệm mớitest_compare.py với mã sau -

def test_greater():
   num = 100
   assert num > 100

def test_greater_equal():
   num = 100
   assert num >= 100

def test_less():
   num = 100
   assert num < 200

Bây giờ để chạy tất cả các bài kiểm tra từ tất cả các tệp (2 tệp ở đây), chúng ta cần chạy lệnh sau:

pytest -v

Lệnh trên sẽ chạy các bài kiểm tra từ cả hai test_square.py và test_compare.py. Đầu ra sẽ được tạo như sau:

test_compare.py::test_greater FAILED
test_compare.py::test_greater_equal PASSED
test_compare.py::test_less PASSED
test_square.py::test_sqrt PASSED
test_square.py::testsquare FAILED
================================================ FAILURES 
================================================
______________________________________________ test_greater 
______________________________________________
   def test_greater():
   num = 100
>  assert num > 100
E  assert 100 > 100

test_compare.py:3: AssertionError
_______________________________________________ testsquare 
_______________________________________________
   def testsquare():
   num = 7
>  assert 7*7 == 40
E  assert (7 * 7) == 40

test_square.py:9: AssertionError
=================================== 2 failed, 3 passed in 0.07 seconds 
===================================

Để thực hiện các bài kiểm tra từ một tệp cụ thể, hãy sử dụng cú pháp sau:

pytest <filename> -v

Bây giờ, hãy chạy lệnh sau:

pytest test_compare.py -v

Lệnh trên sẽ chỉ thực hiện các bài kiểm tra từ tệp test_compare.py. Kết quả của chúng tôi sẽ là -

test_compare.py::test_greater FAILED
test_compare.py::test_greater_equal PASSED
test_compare.py::test_less PASSED
============================================== FAILURES 
==============================================
____________________________________________ test_greater 
____________________________________________
   def test_greater():
   num = 100
>  assert num > 100
E  assert 100 > 100
test_compare.py:3: AssertionError
================================= 1 failed, 2 passed in 0.04 seconds 
=================================

Trong một kịch bản thực tế, chúng tôi sẽ có nhiều tệp thử nghiệm và mỗi tệp sẽ có một số thử nghiệm. Các bài kiểm tra sẽ bao gồm các mô-đun và chức năng khác nhau. Giả sử, chúng ta chỉ muốn chạy một tập hợp các bài kiểm tra cụ thể; Làm thế nào để chúng ta đi về nó?

Pytest cung cấp hai cách để chạy tập hợp con của bộ thử nghiệm.

• Chọn các bài kiểm tra để chạy dựa trên kết hợp chuỗi con của tên bài kiểm tra.
• Chọn các nhóm kiểm tra để chạy dựa trên các điểm đánh dấu được áp dụng.

Chúng tôi sẽ giải thích hai điều này với các ví dụ trong các chương tiếp theo.

Để thực hiện các bài kiểm tra có chứa một chuỗi trong tên của nó, chúng ta có thể sử dụng cú pháp sau:

pytest -k <substring> -v

-k <chuỗi con> đại diện cho chuỗi con cần tìm kiếm trong tên thử nghiệm.

Bây giờ, hãy chạy lệnh sau:

pytest -k great -v

Điều này sẽ thực thi tất cả các tên thử nghiệm có từ ‘great’trong tên của nó. Trong trường hợp này, họtest_greater() và test_greater_equal(). Xem kết quả bên dưới.

test_compare.py::test_greater FAILED
test_compare.py::test_greater_equal PASSED
============================================== FAILURES 
==============================================
____________________________________________ test_greater 
____________________________________________
def test_greater():
num = 100
>  assert num > 100
E  assert 100 > 100
test_compare.py:3: AssertionError
========================== 1 failed, 1 passed, 3 deselected in 0.07 seconds 
==========================

Ở đây trong kết quả, chúng ta có thể thấy 3 bài kiểm tra được bỏ chọn. Điều này là do những tên thử nghiệm đó không chứa từgreat trong chúng.

Note - Tên của hàm kiểm tra vẫn nên bắt đầu bằng 'kiểm tra'.

Trong chương này, chúng ta sẽ học cách nhóm các bài kiểm tra bằng cách sử dụng các điểm đánh dấu.

Pytest cho phép chúng tôi sử dụng các điểm đánh dấu trên các chức năng kiểm tra. Các điểm đánh dấu được sử dụng để đặt các tính năng / thuộc tính khác nhau để kiểm tra các chức năng. Pytest cung cấp nhiều điểm đánh dấu sẵn có như xfail, bỏ qua và tham số. Ngoài ra, người dùng có thể tạo tên điểm đánh dấu của riêng họ. Điểm đánh dấu được áp dụng trong các bài kiểm tra bằng cú pháp đưa ra bên dưới:

@pytest.mark.<markername>

Để sử dụng các điểm đánh dấu, chúng ta phải import pytestmô-đun trong tệp thử nghiệm. Chúng tôi có thể xác định tên điểm đánh dấu của riêng mình cho các bài kiểm tra và chạy các bài kiểm tra có các tên điểm đánh dấu đó.

Để chạy các bài kiểm tra đã đánh dấu, chúng ta có thể sử dụng cú pháp sau:

pytest -m <markername> -v

-m <markername> đại diện cho tên đánh dấu của các bài kiểm tra sẽ được thực hiện.

Cập nhật các tệp thử nghiệm của chúng tôi test_compare.py và test_square.pyvới đoạn mã sau. Chúng tôi đang xác định 3 điểm đánh dấu– great, square, others.

test_compare.py

import pytest
@pytest.mark.great
def test_greater():
   num = 100
   assert num > 100

@pytest.mark.great
def test_greater_equal():
   num = 100
   assert num >= 100

@pytest.mark.others
def test_less():
   num = 100
   assert num < 200

test_square.py

import pytest
import math

@pytest.mark.square
def test_sqrt():
   num = 25
   assert math.sqrt(num) == 5

@pytest.mark.square
def testsquare():
   num = 7
   assert 7*7 == 40

@pytest.mark.others
   def test_equality():
   assert 10 == 11

Bây giờ để chạy các bài kiểm tra được đánh dấu là others, chạy lệnh sau:

pytest -m others -v

Xem kết quả bên dưới. Nó đã chạy 2 bài kiểm tra được đánh dấu làothers.

test_compare.py::test_less PASSED
test_square.py::test_equality FAILED
============================================== FAILURES
==============================================
___________________________________________ test_equality
____________________________________________
   @pytest.mark.others
   def test_equality():
>  assert 10 == 11
E  assert 10 == 11
test_square.py:16: AssertionError
========================== 1 failed, 1 passed, 4 deselected in 0.08 seconds
==========================

Tương tự, chúng tôi cũng có thể chạy thử nghiệm với các điểm đánh dấu khác - tuyệt vời, hãy so sánh

Fixtures là các chức năng, sẽ chạy trước mỗi chức năng thử nghiệm mà nó được áp dụng. Các đồ đạc được sử dụng để cung cấp một số dữ liệu cho các bài kiểm tra như kết nối cơ sở dữ liệu, URL để kiểm tra và một số loại dữ liệu đầu vào. Do đó, thay vì chạy cùng một đoạn mã cho mọi bài kiểm tra, chúng ta có thể gắn hàm fixture vào các bài kiểm tra và nó sẽ chạy và trả lại dữ liệu cho bài kiểm tra trước khi thực hiện mỗi bài kiểm tra.

Một chức năng được đánh dấu là cố định bởi -

@pytest.fixture

Một hàm kiểm tra có thể sử dụng một vật cố định bằng cách đề cập đến tên vật cố định làm tham số đầu vào.

Tạo một tệp test_div_by_3_6.py và thêm mã bên dưới vào nó

import pytest

@pytest.fixture
def input_value():
   input = 39
   return input

def test_divisible_by_3(input_value):
   assert input_value % 3 == 0

def test_divisible_by_6(input_value):
   assert input_value % 6 == 0

Ở đây, chúng ta có một hàm cố định có tên input_value, cung cấp đầu vào cho các bài kiểm tra. Để truy cập chức năng cố định, các bài kiểm tra phải đề cập đến tên cố định làm tham số đầu vào.

Pytest trong khi quá trình kiểm tra đang được thực thi, sẽ thấy tên cố định là tham số đầu vào. Sau đó, nó thực thi hàm fixture và giá trị trả về được lưu trữ vào tham số đầu vào, tham số này có thể được sử dụng bởi thử nghiệm.

Thực hiện kiểm tra bằng lệnh sau:

pytest -k divisible -v

Lệnh trên sẽ tạo ra kết quả sau:

test_div_by_3_6.py::test_divisible_by_3 PASSED
test_div_by_3_6.py::test_divisible_by_6 FAILED
============================================== FAILURES
==============================================
________________________________________ test_divisible_by_6
_________________________________________
input_value = 39
   def test_divisible_by_6(input_value):
>  assert input_value % 6 == 0
E  assert (39 % 6) == 0
test_div_by_3_6.py:12: AssertionError
========================== 1 failed, 1 passed, 6 deselected in 0.07 seconds
==========================

Tuy nhiên, cách tiếp cận đi kèm với hạn chế của riêng nó. Hàm cố định được xác định bên trong tệp thử nghiệm chỉ có phạm vi trong tệp thử nghiệm. Chúng tôi không thể sử dụng vật cố định đó trong một tệp thử nghiệm khác. Để cung cấp một bộ cố định cho nhiều tệp thử nghiệm, chúng tôi phải xác định hàm cố định trong một tệp có tên là conftest.py.conftest.py được giải thích trong chương tiếp theo.

Chúng tôi có thể xác định các chức năng cố định trong tệp này để làm cho chúng có thể truy cập được trên nhiều tệp thử nghiệm.

Tạo một tệp mới conftest.py và thêm đoạn mã dưới đây vào đó -

import pytest

@pytest.fixture
def input_value():
   input = 39
   return input

Chỉnh sửa test_div_by_3_6.py để loại bỏ chức năng cố định -

import pytest

def test_divisible_by_3(input_value):
   assert input_value % 3 == 0

def test_divisible_by_6(input_value):
   assert input_value % 6 == 0

Tạo một tệp mới test_div_by_13.py -

import pytest

def test_divisible_by_13(input_value):
   assert input_value % 13 == 0

Bây giờ, chúng tôi có các tệp test_div_by_3_6.py và test_div_by_13.py sử dụng vật cố định được xác định trong conftest.py.

Chạy các bài kiểm tra bằng cách thực hiện lệnh sau:

pytest -k divisible -v

Lệnh trên sẽ tạo ra kết quả sau:

test_div_by_13.py::test_divisible_by_13 PASSED
test_div_by_3_6.py::test_divisible_by_3 PASSED
test_div_by_3_6.py::test_divisible_by_6 FAILED
============================================== FAILURES
==============================================
________________________________________ test_divisible_by_6
_________________________________________
input_value = 39
   def test_divisible_by_6(input_value):
>  assert input_value % 6 == 0
E  assert (39 % 6) == 0
test_div_by_3_6.py:7: AssertionError
========================== 1 failed, 2 passed, 6 deselected in 0.09 seconds
==========================

Các bài kiểm tra sẽ tìm kiếm sự cố định trong cùng một tệp. Vì không tìm thấy vật cố định trong tệp, nó sẽ kiểm tra vật cố định trong tệp conftest.py. Khi tìm thấy nó, phương thức fixture được gọi và kết quả được trả về đối số đầu vào của bài kiểm tra.

Việc tham số hóa một bài kiểm tra được thực hiện để chạy bài kiểm tra với nhiều bộ đầu vào. Chúng tôi có thể làm điều này bằng cách sử dụng điểm đánh dấu sau:

@pytest.mark.parametrize

Sao chép mã dưới đây vào một tệp có tên test_multiplication.py -

import pytest

@pytest.mark.parametrize("num, output",[(1,11),(2,22),(3,35),(4,44)])
def test_multiplication_11(num, output):
   assert 11*num == output

Ở đây, phép thử nhân một đầu vào với 11 và so sánh kết quả với đầu ra mong đợi. Bài kiểm tra có 4 bộ đầu vào, mỗi bộ có 2 giá trị - một là số cần nhân với 11 và bộ kia là kết quả mong đợi.

Thực hiện kiểm tra bằng cách chạy lệnh sau:

Pytest -k multiplication -v

Lệnh trên sẽ tạo ra kết quả sau:

test_multiplication.py::test_multiplication_11[1-11] PASSED
test_multiplication.py::test_multiplication_11[2-22] PASSED
test_multiplication.py::test_multiplication_11[3-35] FAILED
test_multiplication.py::test_multiplication_11[4-44] PASSED
============================================== FAILURES
==============================================
_________________ test_multiplication_11[3-35] __________________
num = 3, output = 35
   @pytest.mark.parametrize("num, output",[(1,11),(2,22),(3,35),(4,44)])
   def test_multiplication_11(num, output):
>  assert 11*num == output
E  assert (11 * 3) == 35
test_multiplication.py:5: AssertionError
============================== 1 failed, 3 passed, 8 deselected in 0.08 seconds
==============================

Trong chương này, chúng ta sẽ tìm hiểu về các bài kiểm tra Skip và Xfail trong Pytest.

Bây giờ, hãy xem xét các tình huống dưới đây -

• Một thử nghiệm không phù hợp trong một thời gian do một số lý do.
• Một tính năng mới đang được triển khai và chúng tôi đã thêm một thử nghiệm cho tính năng đó.

Trong những tình huống này, chúng tôi có tùy chọn bỏ qua bài kiểm tra hoặc bỏ qua bài kiểm tra.

Pytest sẽ thực hiện kiểm tra không thành công, nhưng nó sẽ không được coi là một phần không thành công hoặc đã vượt qua kiểm tra. Chi tiết của các bài kiểm tra này sẽ không được in ngay cả khi bài kiểm tra không thành công (hãy nhớ pytest thường in chi tiết bài kiểm tra không thành công). Chúng tôi có thể kiểm tra xfail bằng cách sử dụng điểm đánh dấu sau:

@pytest.mark.xfail

Bỏ qua một bài kiểm tra có nghĩa là bài kiểm tra sẽ không được thực hiện. Chúng tôi có thể bỏ qua các bài kiểm tra bằng cách sử dụng điểm đánh dấu sau:

@pytest.mark.skip

Sau đó, khi bài kiểm tra trở nên phù hợp, chúng tôi có thể xóa các điểm đánh dấu.

Chỉnh sửa test_compare.py chúng tôi đã phải bao gồm các điểm đánh dấu xfail và bỏ qua -

import pytest
@pytest.mark.xfail
@pytest.mark.great
def test_greater():
   num = 100
   assert num > 100

@pytest.mark.xfail
@pytest.mark.great
def test_greater_equal():
   num = 100
   assert num >= 100

@pytest.mark.skip
@pytest.mark.others
def test_less():
   num = 100
   assert num < 200

Thực hiện kiểm tra bằng lệnh sau:

pytest test_compare.py -v

Khi thực hiện, lệnh trên sẽ tạo ra kết quả sau:

test_compare.py::test_greater xfail
test_compare.py::test_greater_equal XPASS
test_compare.py::test_less SKIPPED
============================ 1 skipped, 1 xfailed, 1 xpassed in 0.06 seconds
============================

Trong một kịch bản thực tế, khi một phiên bản mã mới đã sẵn sàng để triển khai, nó sẽ được triển khai lần đầu tiên trong môi trường pre-prod / staging. Sau đó, một bộ thử nghiệm chạy trên đó.

Mã chỉ đủ điều kiện để triển khai đến phiên bản sản xuất nếu bộ thử nghiệm vượt qua. Nếu có lỗi kiểm tra, dù là một hay nhiều, mã đó chưa sẵn sàng sản xuất.

Do đó, điều gì sẽ xảy ra nếu chúng ta muốn dừng việc thực thi bộ thử nghiệm ngay sau khi n số thử nghiệm không thành công. Điều này có thể được thực hiện trong pytest bằng cách sử dụng maxfail.

Cú pháp để dừng việc thực thi bộ thử nghiệm ngay sau khi n số lần thử nghiệm không thành công như sau:

pytest --maxfail = <num>

Tạo tệp test_failure.py bằng mã sau.

import pytest
import math

def test_sqrt_failure():
   num = 25
   assert math.sqrt(num) == 6

def test_square_failure():
   num = 7
   assert 7*7 == 40

def test_equality_failure():
   assert 10 == 11

Tất cả 3 bài kiểm tra sẽ không thành công khi thực hiện tệp kiểm tra này. Ở đây, chúng tôi sẽ dừng việc thực hiện kiểm tra sau một lần thất bại bằng cách -

pytest test_failure.py -v --maxfail = 1

test_failure.py::test_sqrt_failure FAILED
=================================== FAILURES
=================================== _______________________________________
test_sqrt_failure __________________________________________
   def test_sqrt_failure():
   num = 25
>  assert math.sqrt(num) == 6
E  assert 5.0 == 6
E  + where 5.0 = <built-in function sqrt>(25)
E  + where <built-in function sqrt>= math.sqrt
test_failure.py:6: AssertionError
=============================== 1 failed in 0.04 seconds
===============================

Trong kết quả trên, chúng ta có thể thấy việc thực thi bị dừng lại sau một lần thất bại.

Theo mặc định, pytest chạy các bài kiểm tra theo thứ tự tuần tự. Trong một kịch bản thực tế, một bộ thử nghiệm sẽ có một số tệp thử nghiệm và mỗi tệp sẽ có một loạt các thử nghiệm. Điều này sẽ dẫn đến thời gian thực hiện lớn. Để khắc phục điều này, pytest cung cấp cho chúng ta một tùy chọn để chạy thử nghiệm song song.

Đối với điều này, trước tiên chúng ta cần cài đặt plugin pytest-xdist.

Cài đặt pytest-xdist bằng cách chạy lệnh sau:

pip install pytest-xdist

Bây giờ, chúng ta có thể chạy các bài kiểm tra bằng cách sử dụng cú pháp pytest -n <num>

pytest -n 3

-n <num> chạy các bài kiểm tra bằng cách sử dụng nhiều công nhân, đây là 3.

Chúng tôi sẽ không có nhiều chênh lệch múi giờ khi chỉ có một số thử nghiệm để chạy. Tuy nhiên, vấn đề quan trọng khi bộ thử nghiệm lớn.

Chúng tôi có thể tạo các chi tiết của việc thực thi thử nghiệm trong một tệp xml. Tệp xml này chủ yếu hữu ích trong trường hợp chúng tôi có một bảng điều khiển chiếu kết quả thử nghiệm. Trong những trường hợp như vậy, xml có thể được phân tích cú pháp để lấy thông tin chi tiết về việc thực thi.

Bây giờ chúng tôi sẽ thực hiện các bài kiểm tra từ test_multiplcation.py và tạo xml bằng cách chạy

pytest test_multiplication.py -v --junitxml="result.xml"

Bây giờ chúng ta có thể thấy result.xml được tạo với dữ liệu sau:

<?xml version = "1.0" encoding = "utf-8"?>
<testsuite errors = "0" failures = "1"
name = "pytest" skips = "0" tests = "4" time = "0.061">
   <testcase classname = "test_multiplication"          
      file = "test_multiplication.py"
      line = "2" name = "test_multiplication_11[1-11]"
      time = "0.00117516517639>
   </testcase>
   
   <testcase classname = "test_multiplication"    
      file = "test_multiplication.py"
      line = "2" name = "test_multiplication_11[2-22]"
      time = "0.00155973434448">
   </testcase>

   <testcase classname = "test_multiplication" 
      file = "test_multiplication.py"
      line = "2" name = "test_multiplication_11[3-35]" time = "0.00144290924072">
      failure message = "assert (11 * 3) == 35">num = 3, output = 35

         @pytest.mark.parametrize("num,
         output",[(1,11),(2,22),(3,35),(4,44)])
            
         def test_multiplication_11(num, output):> 
         assert 11*num == output
         E assert (11 * 3) == 35

         test_multiplication.py:5: AssertionErro
      </failure>
   </testcase>
   <testcase classname = "test_multiplication" 
      file = "test_multiplication.py"
      line = "2" name = "test_multiplication_11[4-44]"
      time = "0.000945091247559">
   </testcase>
</testsuite>

Đây, thẻ <testsuit> tổng kết có 4 bài thi và số bài không đạt là 1 bài.

• Tag <testcase> đưa ra các chi tiết của từng thử nghiệm đã thực hiện.

• Thẻ <failure> cung cấp thông tin chi tiết của mã kiểm tra không thành công.

Trong hướng dẫn pytest này, chúng tôi đã đề cập đến các lĩnh vực sau:

• Đang cài đặt pytest ..
• Xác định các tệp kiểm tra và chức năng kiểm tra.
• Thực thi tất cả các tệp thử nghiệm bằng pytest –v.
• Thực thi tệp cụ thể usimng pytest <tên tệp> -v.
• Thực hiện các bài kiểm tra bằng cách so khớp chuỗi con pytest -k <chuỗi con> -v.
• Thực hiện các bài kiểm tra dựa trên điểm đánh dấu pytest -m <marker_name> -v.
• Tạo đồ đạc bằng @ pytest.fixture.
• conftest.py cho phép truy cập đồ đạc từ nhiều tệp.
• Kiểm tra tham số bằng @ pytest.mark.parametrize.
• Kiểm tra Xfailing bằng cách sử dụng @ pytest.mark.xfail.
• Bỏ qua các bài kiểm tra bằng @ pytest.mark.skip.
• Dừng thực thi thử nghiệm trên n lỗi bằng cách sử dụng pytest --maxfail = <num>.
• Chạy thử nghiệm song song bằng cách sử dụng pytest -n <num>.
• Tạo kết quả xml bằng pytest -v --junitxml = "result.xml".

Hướng dẫn này đã giới thiệu cho bạn về khung công tác pytest. Bây giờ bạn có thể bắt đầu viết các bài kiểm tra bằng pytest.

Như một thông lệ tốt -

• Tạo các tệp thử nghiệm khác nhau dựa trên chức năng / mô-đun đang được thử nghiệm.
• Đặt tên có ý nghĩa cho các tệp và phương thức kiểm tra.
• Có đủ điểm đánh dấu để nhóm các bài kiểm tra dựa trên các tiêu chí khác nhau.
• Sử dụng đồ đạc bất cứ khi nào cần thiết.