Hướng dẫn how do i test a python script? - làm cách nào để kiểm tra tập lệnh python?

Kiểm tra tự động so với kiểm tra thủ công

Tin tốt là, bạn có lẽ đã tạo ra một bài kiểm tra mà không nhận ra nó. Bạn có nhớ khi bạn chạy ứng dụng của mình và sử dụng nó lần đầu tiên không? Bạn đã kiểm tra các tính năng và thử nghiệm bằng cách sử dụng chúng? Đó được gọi là thử nghiệm khám phá và là một hình thức thử nghiệm thủ công.exploratory testing and is a form of manual testing.

Thử nghiệm khám phá là một hình thức thử nghiệm được thực hiện mà không có kế hoạch. Trong một bài kiểm tra khám phá, bạn chỉ cần khám phá ứng dụng.

Để có một bộ kiểm tra thủ công đầy đủ, tất cả những gì bạn cần làm là lập danh sách tất cả các tính năng của ứng dụng của bạn, các loại đầu vào khác nhau có thể chấp nhận và kết quả dự kiến. Bây giờ, mỗi khi bạn thực hiện thay đổi mã của mình, bạn cần phải đi qua từng mục trong danh sách đó và kiểm tra nó.

Điều đó có vẻ như rất nhiều niềm vui, phải không?

Đây là nơi thử nghiệm tự động xuất hiện. Kiểm tra tự động là việc thực hiện kế hoạch thử nghiệm của bạn (các phần của ứng dụng bạn muốn kiểm tra, thứ tự bạn muốn kiểm tra chúng và các phản hồi dự kiến) . Python đã đi kèm với một bộ công cụ và thư viện để giúp bạn tạo các thử nghiệm tự động cho ứng dụng của mình. Chúng tôi sẽ khám phá những công cụ và thư viện trong hướng dẫn này.

Bài kiểm tra đơn vị so với kiểm tra tích hợp

Thế giới thử nghiệm không thiếu thuật ngữ, và bây giờ bạn biết sự khác biệt giữa thử nghiệm tự động và thủ công, đó là thời gian để đi sâu hơn.

Hãy nghĩ về cách bạn có thể kiểm tra đèn trên xe. Bạn sẽ bật đèn (được gọi là bước thử nghiệm) và đi ra ngoài xe hoặc yêu cầu một người bạn kiểm tra xem đèn có bật không (được gọi là khẳng định thử nghiệm). Kiểm tra nhiều thành phần được gọi là thử nghiệm tích hợp.test step) and go outside the car or ask a friend to check that the lights are on (known as the test assertion). Testing multiple components is known as integration testing.

Hãy nghĩ về tất cả những điều cần làm việc chính xác để một nhiệm vụ đơn giản để đưa ra kết quả đúng đắn. Các thành phần này giống như các phần cho ứng dụng của bạn, tất cả các lớp, chức năng và mô -đun mà bạn đã viết.

Một thách thức lớn với thử nghiệm tích hợp là khi một thử nghiệm tích hợp không cho kết quả đúng. Nó rất khó để chẩn đoán vấn đề mà không thể cô lập phần nào của hệ thống đang thất bại. Nếu đèn không bật, thì có lẽ các bóng đèn bị hỏng. Pin có chết không? Còn máy phát điện thì sao? Máy tính xe hơi có bị lỗi không?

Nếu bạn có một chiếc xe hiện đại lạ mắt, nó sẽ cho bạn biết khi bóng đèn của bạn đã biến mất. Nó thực hiện điều này bằng cách sử dụng một hình thức kiểm tra đơn vị.unit test.

Một bài kiểm tra đơn vị là một thử nghiệm nhỏ hơn, một thử nghiệm xem một thành phần duy nhất có hoạt động đúng cách không. Một bài kiểm tra đơn vị giúp bạn cô lập những gì bị hỏng trong ứng dụng của bạn và sửa nó nhanh hơn.

Bạn vừa thấy hai loại bài kiểm tra:

1. Kiểm tra tích hợp kiểm tra các thành phần trong ứng dụng của bạn hoạt động với nhau.
2. Một bài kiểm tra đơn vị kiểm tra một thành phần nhỏ trong ứng dụng của bạn.

Bạn có thể viết cả kiểm tra tích hợp và kiểm tra đơn vị trong Python. Để viết một bài kiểm tra đơn vị cho chức năng tích hợp

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

Ví dụ: ở đây, cách bạn kiểm tra xem

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

>>>

>>> assert sum([1, 2, 3]) == 6, "Should be 6"

Điều này sẽ không xuất ra bất cứ điều gì trên repress vì các giá trị là chính xác.

Nếu kết quả từ

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

$ python test_sum_2.py
Traceback (most recent call last):
  File "test_sum_2.py", line 9, in 
    test_sum_tuple()
  File "test_sum_2.py", line 5, in test_sum_tuple
    assert sum((1, 2, 2)) == 6, "Should be 6"
AssertionError: Should be 6

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

>>>

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Điều này sẽ không xuất ra bất cứ điều gì trên repress vì các giá trị là chính xác.

Nếu kết quả từ

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

$ python test_sum_2.py
Traceback (most recent call last):
  File "test_sum_2.py", line 9, in 
    test_sum_tuple()
  File "test_sum_2.py", line 5, in test_sum_tuple
    assert sum((1, 2, 2)) == 6, "Should be 6"
AssertionError: Should be 6

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Trong bản sao, bạn đang thấy

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

$ python test_sum.py
Everything passed

Bạn có thể thấy kết quả thành công,

$ python test_sum_2.py
Traceback (most recent call last):
  File "test_sum_2.py", line 9, in 
    test_sum_tuple()
  File "test_sum_2.py", line 5, in test_sum_tuple
    assert sum((1, 2, 2)) == 6, "Should be 6"
AssertionError: Should be 6

Trong Python,

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

$ python test_sum_2.py
Traceback (most recent call last):
  File "test_sum_2.py", line 9, in 
    test_sum_tuple()
  File "test_sum_2.py", line 5, in test_sum_tuple
    assert sum((1, 2, 2)) == 6, "Should be 6"
AssertionError: Should be 6

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

Khi bạn thực thi

$ python test_sum_2.py
Traceback (most recent call last):
  File "test_sum_2.py", line 9, in 
    test_sum_tuple()
  File "test_sum_2.py", line 5, in test_sum_tuple
    assert sum((1, 2, 2)) == 6, "Should be 6"
AssertionError: Should be 6

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

$ python test_sum_2.py
Traceback (most recent call last):
  File "test_sum_2.py", line 9, in 
    test_sum_tuple()
  File "test_sum_2.py", line 5, in test_sum_tuple
    assert sum((1, 2, 2)) == 6, "Should be 6"
AssertionError: Should be 6

Ở đây bạn có thể thấy một lỗi trong mã của bạn gây ra lỗi trên bảng điều khiển với một số thông tin về lỗi ở đâu và kết quả dự kiến ​​là gì.

Viết bài kiểm tra theo cách này là ổn cho một kiểm tra đơn giản, nhưng nếu có nhiều hơn một thất bại? Đây là nơi các vận động viên kiểm tra đến. Người chạy thử là một ứng dụng đặc biệt được thiết kế để chạy thử nghiệm, kiểm tra đầu ra và cung cấp cho bạn các công cụ để gỡ lỗi và chẩn đoán các xét nghiệm và ứng dụng.

Chọn một người chạy thử nghiệm

Có rất nhiều vận động viên kiểm tra có sẵn cho Python. Một cái được xây dựng vào thư viện tiêu chuẩn Python được gọi là

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

• import unittest
  
  
  class TestSum(unittest.TestCase):
  
      def test_sum(self):
          self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")
  
      def test_sum_tuple(self):
          self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
  
  if __name__ == '__main__':
      unittest.main()
  

  4

• import unittest
  
  
  class TestSum(unittest.TestCase):
  
      def test_sum(self):
          self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")
  
      def test_sum_tuple(self):
          self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
  
  if __name__ == '__main__':
      unittest.main()
  

  9 hoặc

  $ python test_sum_unittest.py
  .F
  ======================================================================
  FAIL: test_sum_tuple (__main__.TestSum)
  ----------------------------------------------------------------------
  Traceback (most recent call last):
    File "test_sum_unittest.py", line 9, in test_sum_tuple
      self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
  AssertionError: Should be 6
  
  ----------------------------------------------------------------------
  Ran 2 tests in 0.001s
  
  FAILED (failures=1)
  

  0

• $ python test_sum_unittest.py
  .F
  ======================================================================
  FAIL: test_sum_tuple (__main__.TestSum)
  ----------------------------------------------------------------------
  Traceback (most recent call last):
    File "test_sum_unittest.py", line 9, in test_sum_tuple
      self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
  AssertionError: Should be 6
  
  ----------------------------------------------------------------------
  Ran 2 tests in 0.001s
  
  FAILED (failures=1)
  

  1

Chọn người chạy thử nghiệm tốt nhất cho các yêu cầu và mức độ kinh nghiệm của bạn là rất quan trọng.

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

Viết bài kiểm tra ở đâu

Để bắt đầu viết bài kiểm tra, bạn chỉ cần tạo một tệp có tên

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Bạn sẽ thấy rằng, khi bạn thêm ngày càng nhiều thử nghiệm, tệp đơn của bạn sẽ trở nên lộn xộn và khó duy trì, vì vậy bạn có thể tạo một thư mục có tên

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Cách cấu trúc một bài kiểm tra đơn giản

Trước khi bạn đi sâu vào các bài kiểm tra viết, trước tiên bạn sẽ muốn đưa ra một vài quyết định:

1. Bạn muốn kiểm tra điều gì?
2. Bạn đang viết một bài kiểm tra đơn vị hoặc kiểm tra tích hợp?

Sau đó, cấu trúc của một bài kiểm tra sẽ tuân theo quy trình công việc này một cách lỏng lẻo:

1. Tạo đầu vào của bạn
2. Thực thi mã đang được kiểm tra, nắm bắt đầu ra
3. So sánh đầu ra với kết quả dự kiến

Đối với ứng dụng này, bạn đã thử nghiệm

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

• Nó có thể tổng hợp một danh sách toàn bộ số (số nguyên) không?
• Nó có thể tổng hợp một tuple hoặc đặt?
• Nó có thể tổng hợp một danh sách phao không?
• Điều gì xảy ra khi bạn cung cấp cho nó một giá trị xấu, chẳng hạn như một số nguyên hoặc một chuỗi?
• Điều gì xảy ra khi một trong các giá trị là âm?

Bài kiểm tra đơn giản nhất sẽ là một danh sách các số nguyên. Tạo một tệp,

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Ví dụ về mã này:

1. Nhập

   def test_sum():
       assert sum([1, 2, 3]) == 6, "Should be 6"
   
   def test_sum_tuple():
       assert sum((1, 2, 2)) == 6, "Should be 6"
   
   if __name__ == "__main__":
       test_sum()
       test_sum_tuple()
       print("Everything passed")
   

   3 từ gói

   >>> assert sum([1, 1, 1]) == 6, "Should be 6"
   Traceback (most recent call last):
     File "", line 1, in 
   AssertionError: Should be 6
   

   23 bạn đã tạo

2. Xác định một lớp trường hợp thử nghiệm mới được gọi là

   $ pip install nose2
   $ python -m nose2
   .F
   ======================================================================
   FAIL: test_sum_tuple (__main__.TestSum)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
     File "test_sum_unittest.py", line 9, in test_sum_tuple
       self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
   AssertionError: Should be 6
   
   ----------------------------------------------------------------------
   Ran 2 tests in 0.001s
   
   FAILED (failures=1)
   

   1, được kế thừa từ

   $ python test_sum_unittest.py
   .F
   ======================================================================
   FAIL: test_sum_tuple (__main__.TestSum)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
     File "test_sum_unittest.py", line 9, in test_sum_tuple
       self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
   AssertionError: Should be 6
   
   ----------------------------------------------------------------------
   Ran 2 tests in 0.001s
   
   FAILED (failures=1)
   

   7

3. Xác định một phương pháp kiểm tra,

   >>> assert sum([1, 1, 1]) == 6, "Should be 6"
   Traceback (most recent call last):
     File "", line 1, in 
   AssertionError: Should be 6
   

   44, để kiểm tra danh sách các số nguyên. Phương pháp

   >>> assert sum([1, 1, 1]) == 6, "Should be 6"
   Traceback (most recent call last):
     File "", line 1, in 
   AssertionError: Should be 6
   

   44 sẽ:
   • Khai báo một biến

     >>> assert sum([1, 1, 1]) == 6, "Should be 6"
     Traceback (most recent call last):
       File "", line 1, in 
     AssertionError: Should be 6
     

     46 với danh sách các số

     def test_sum():
         assert sum([1, 2, 3]) == 6, "Should be 6"
     
     def test_sum_tuple():
         assert sum((1, 2, 2)) == 6, "Should be 6"
     
     if __name__ == "__main__":
         test_sum()
         test_sum_tuple()
         print("Everything passed")
     

     6
   • Gán kết quả của

     >>> assert sum([1, 1, 1]) == 6, "Should be 6"
     Traceback (most recent call last):
       File "", line 1, in 
     AssertionError: Should be 6
     

     48 cho biến

     >>> assert sum([1, 1, 1]) == 6, "Should be 6"
     Traceback (most recent call last):
       File "", line 1, in 
     AssertionError: Should be 6
     

     49
   • Khẳng định rằng giá trị của

     >>> assert sum([1, 1, 1]) == 6, "Should be 6"
     Traceback (most recent call last):
       File "", line 1, in 
     AssertionError: Should be 6
     

     49 bằng

     def test_sum():
         assert sum([1, 2, 3]) == 6, "Should be 6"
     
     def test_sum_tuple():
         assert sum((1, 2, 2)) == 6, "Should be 6"
     
     if __name__ == "__main__":
         test_sum()
         test_sum_tuple()
         print("Everything passed")
     

     7 bằng cách sử dụng phương thức

     >>> assert sum([1, 1, 1]) == 6, "Should be 6"
     Traceback (most recent call last):
       File "", line 1, in 
     AssertionError: Should be 6
     

     52 trên lớp

     $ python test_sum_unittest.py
     .F
     ======================================================================
     FAIL: test_sum_tuple (__main__.TestSum)
     ----------------------------------------------------------------------
     Traceback (most recent call last):
       File "test_sum_unittest.py", line 9, in test_sum_tuple
         self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
     AssertionError: Should be 6
     
     ----------------------------------------------------------------------
     Ran 2 tests in 0.001s
     
     FAILED (failures=1)
     

     7

4. Xác định điểm vào dòng lệnh, chạy bộ kiểm tra

   import unittest
   
   
   class TestSum(unittest.TestCase):
   
       def test_sum(self):
           self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")
   
       def test_sum_tuple(self):
           self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
   
   if __name__ == '__main__':
       unittest.main()
   

   4

   >>> assert sum([1, 1, 1]) == 6, "Should be 6"
   Traceback (most recent call last):
     File "", line 1, in 
   AssertionError: Should be 6
   

   55

Nếu bạn không chắc chắn

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Cách viết các xác nhận

Bước cuối cùng của việc viết bài kiểm tra là xác nhận đầu ra so với phản hồi đã biết. Điều này được gọi là một khẳng định. Có một số thực tiễn tốt nhất xung quanh cách viết khẳng định:assertion. There are some general best practices around how to write assertions:

• Đảm bảo các bài kiểm tra có thể lặp lại và chạy bài kiểm tra của bạn nhiều lần để đảm bảo nó mang lại kết quả tương tự mỗi lần
• Hãy thử và khẳng định các kết quả liên quan đến dữ liệu đầu vào của bạn, chẳng hạn như kiểm tra xem kết quả là tổng giá trị thực tế trong ví dụ

  def test_sum():
      assert sum([1, 2, 3]) == 6, "Should be 6"
  
  def test_sum_tuple():
      assert sum((1, 2, 2)) == 6, "Should be 6"
  
  if __name__ == "__main__":
      test_sum()
      test_sum_tuple()
      print("Everything passed")
  

  3

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Phản ứng phụ

Khi bạn viết các bài kiểm tra, nó thường không đơn giản như nhìn vào giá trị trả về của một hàm. Thông thường, việc thực thi một đoạn mã sẽ thay đổi những thứ khác trong môi trường, chẳng hạn như thuộc tính của một lớp, một tệp trên hệ thống tập tin hoặc giá trị trong cơ sở dữ liệu. Chúng được gọi là tác dụng phụ và là một phần quan trọng của thử nghiệm. Quyết định xem tác dụng phụ đang được kiểm tra trước khi đưa nó vào danh sách các xác nhận của bạn.side effects and are an important part of testing. Decide if the side effect is being tested before including it in your list of assertions.

Nếu bạn thấy rằng đơn vị mã bạn muốn kiểm tra có rất nhiều tác dụng phụ, bạn có thể phá vỡ nguyên tắc trách nhiệm duy nhất. Phá vỡ nguyên tắc trách nhiệm duy nhất có nghĩa là phần mã đang làm quá nhiều thứ và sẽ tốt hơn khi được tái cấu trúc. Theo nguyên tắc trách nhiệm duy nhất là một cách tuyệt vời để thiết kế mã dễ dàng để viết các bài kiểm tra đơn vị đơn giản và lặp lại và cuối cùng là các ứng dụng đáng tin cậy.

Thực hiện các vận động viên kiểm tra

Ứng dụng Python thực thi mã kiểm tra của bạn, kiểm tra các xác nhận và cung cấp cho bạn kết quả kiểm tra trong bảng điều khiển của bạn được gọi là người chạy thử.test runner.

Ở dưới cùng của

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Đây là một điểm nhập dòng lệnh. Điều đó có nghĩa là nếu bạn thực hiện tập lệnh một mình bằng cách chạy

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

Đây là một trong nhiều cách để thực hiện người chạy thử nghiệm

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Một cách khác là sử dụng dòng lệnh

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Điều này sẽ thực thi cùng một mô -đun thử nghiệm (được gọi là

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Bạn có thể cung cấp các tùy chọn bổ sung để thay đổi đầu ra. Một trong số đó là

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Điều này đã thực hiện một thử nghiệm bên trong

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Thay vì cung cấp tên của một mô-đun có chứa các bài kiểm tra, bạn có thể yêu cầu khám phá tự động bằng cách sử dụng những điều sau:

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Điều này sẽ tìm kiếm thư mục hiện tại cho bất kỳ tệp nào có tên

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

Khi bạn có nhiều tệp kiểm tra, miễn là bạn theo mẫu đặt tên

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

Cuối cùng, nếu mã nguồn của bạn không nằm trong root thư mục và có trong thư mục con, ví dụ trong thư mục có tên

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Hiểu đầu ra kiểm tra

Đó là một ví dụ rất đơn giản trong đó mọi thứ trôi qua, vì vậy bây giờ bạn sẽ thử một bài kiểm tra thất bại và giải thích đầu ra.

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")

Ở đầu tệp

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Bây giờ thêm một bài kiểm tra với một khẳng định mong đợi giá trị không chính xác, trong trường hợp này mong đợi tổng số 1/4, 1/4 và 2/5 là 1:

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Nếu bạn thực hiện lại các bài kiểm tra với

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Trong đầu ra, bạn sẽ thấy các thông tin sau:

1. Dòng đầu tiên cho thấy kết quả thực thi của tất cả các thử nghiệm, một lần thất bại (

   $ pip install nose2
   $ python -m nose2
   .F
   ======================================================================
   FAIL: test_sum_tuple (__main__.TestSum)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
     File "test_sum_unittest.py", line 9, in test_sum_tuple
       self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
   AssertionError: Should be 6
   
   ----------------------------------------------------------------------
   Ran 2 tests in 0.001s
   
   FAILED (failures=1)
   

   9) và một lần được thông qua (

   $ pip install nose2
   $ python -m nose2
   .F
   ======================================================================
   FAIL: test_sum_tuple (__main__.TestSum)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
     File "test_sum_unittest.py", line 9, in test_sum_tuple
       self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
   AssertionError: Should be 6
   
   ----------------------------------------------------------------------
   Ran 2 tests in 0.001s
   
   FAILED (failures=1)
   

   8).

2. Mục nhập

   def test_sum():
       assert sum([1, 2, 3]) == 6, "Should be 6"
   
   if __name__ == "__main__":
       test_sum()
       print("Everything passed")
   

   08 hiển thị một số chi tiết về bài kiểm tra thất bại:
   • Tên phương thức kiểm tra (

     def test_sum():
         assert sum([1, 2, 3]) == 6, "Should be 6"
     
     if __name__ == "__main__":
         test_sum()
         print("Everything passed")
     

     09)
   • Mô -đun thử nghiệm (

     >>> assert sum([1, 1, 1]) == 6, "Should be 6"
     Traceback (most recent call last):
       File "", line 1, in 
     AssertionError: Should be 6
     

     87) và trường hợp thử nghiệm (

     $ pip install nose2
     $ python -m nose2
     .F
     ======================================================================
     FAIL: test_sum_tuple (__main__.TestSum)
     ----------------------------------------------------------------------
     Traceback (most recent call last):
       File "test_sum_unittest.py", line 9, in test_sum_tuple
         self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
     AssertionError: Should be 6
     
     ----------------------------------------------------------------------
     Ran 2 tests in 0.001s
     
     FAILED (failures=1)
     

     1)
   • Một dấu vết cho dòng thất bại
   • Các chi tiết của khẳng định với kết quả dự kiến ​​(

     def test_sum():
         assert sum([1, 2, 3]) == 6, "Should be 6"
     
     if __name__ == "__main__":
         test_sum()
         print("Everything passed")
     

     12) và kết quả thực tế (

     def test_sum():
         assert sum([1, 2, 3]) == 6, "Should be 6"
     
     if __name__ == "__main__":
         test_sum()
         print("Everything passed")
     

     13)

Hãy nhớ rằng, bạn có thể thêm thông tin bổ sung vào đầu ra thử nghiệm bằng cách thêm cờ

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Chạy các bài kiểm tra của bạn từ Pycharm

Nếu bạn sử dụng IDE pycharm, bạn có thể chạy

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

1. Trong cửa sổ công cụ dự án, chọn thư mục

   def test_sum():
       assert sum([1, 2, 3]) == 6, "Should be 6"
   
   if __name__ == "__main__":
       test_sum()
       print("Everything passed")
   

   00.
2. Trên menu ngữ cảnh, chọn lệnh chạy cho

   import unittest
   
   
   class TestSum(unittest.TestCase):
   
       def test_sum(self):
           self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")
   
       def test_sum_tuple(self):
           self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
   
   if __name__ == '__main__':
       unittest.main()
   

   4. Ví dụ: chọn Run Unittests trong các bài kiểm tra của tôi.

Điều này sẽ thực thi

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

Thông tin thêm có sẵn trên trang web Pycharm.

Chạy các bài kiểm tra của bạn từ Visual Studio Code

Nếu bạn sử dụng Microsoft Visual Studio Code IDE, hãy hỗ trợ thực hiện

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

Nếu bạn đã cài đặt plugin Python, bạn có thể thiết lập cấu hình cho các thử nghiệm của mình bằng cách mở bảng lệnh bằng Ctrl+Shift+P và gõ bài kiểm tra Python Python. Bạn sẽ thấy một loạt các tùy chọn:Ctrl+Shift+P and typing “Python test”. You will see a range of options:

Chọn gỡ lỗi tất cả các thử nghiệm đơn vị và VSCode sau đó sẽ nâng cao một lời nhắc để định cấu hình khung thử nghiệm. Nhấp vào COG để chọn người chạy thử (

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

Khi điều này được thiết lập, bạn sẽ thấy trạng thái của các bài kiểm tra ở dưới cùng của cửa sổ và bạn có thể nhanh chóng truy cập nhật ký kiểm tra và chạy lại các thử nghiệm bằng cách nhấp vào các biểu tượng này:

Điều này cho thấy các bài kiểm tra đang thực hiện, nhưng một số trong số chúng đang thất bại.

Tại sao họ khác với các ứng dụng khác

Hãy nghĩ về tất cả các mã mà bạn sẽ thử nghiệm trong một ứng dụng web. Tất cả các tuyến đường, chế độ xem và mô hình đều yêu cầu nhiều nhập khẩu và kiến ​​thức về các khung đang được sử dụng.

Điều này tương tự như thử nghiệm xe hơi khi bắt đầu hướng dẫn: bạn phải khởi động máy tính xe hơi trước khi bạn có thể chạy thử nghiệm đơn giản như kiểm tra đèn.

Django và Flask đều giúp bạn dễ dàng bằng cách cung cấp khung thử nghiệm dựa trên

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

Cách sử dụng người chạy thử nghiệm Django

Mẫu Django

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Sự khác biệt chính với các ví dụ cho đến nay là bạn cần phải thừa hưởng từ

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

$ python test_sum_unittest.py
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

$ pip install nose2
$ python -m nose2
.F
======================================================================
FAIL: test_sum_tuple (__main__.TestSum)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_sum_unittest.py", line 9, in test_sum_tuple
    self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")
AssertionError: Should be 6

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

Để thực hiện bộ thử nghiệm của bạn, thay vì sử dụng

import unittest


class TestSum(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Nếu bạn muốn có nhiều tệp thử nghiệm, hãy thay thế

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

>>> assert sum([1, 1, 1]) == 6, "Should be 6"
Traceback (most recent call last):
  File "", line 1, in 
AssertionError: Should be 6

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Thông tin thêm có sẵn tại trang web tài liệu Django.

Cách sử dụng import unittest class TestSum(unittest.TestCase): def test_sum(self): self.assertEqual(sum([1, 2, 3]), 6, "Should be 6") def test_sum_tuple(self): self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") if __name__ == '__main__': unittest.main() 4 và bình

Bình yêu cầu ứng dụng phải được nhập và sau đó đặt ở chế độ thử nghiệm. Bạn có thể khởi tạo máy khách thử nghiệm và sử dụng ứng dụng khách thử nghiệm để thực hiện yêu cầu cho bất kỳ tuyến đường nào trong ứng dụng của bạn.

Tất cả các máy khách kiểm tra khởi tạo được thực hiện trong phương pháp

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Mã trong tệp kiểm tra của bạn sẽ trông như thế này:

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Sau đó, bạn có thể thực hiện các trường hợp kiểm tra bằng lệnh

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    print("Everything passed")

Thông tin thêm có sẵn tại trang web tài liệu Flask.

Xử lý thất bại dự kiến

Trước đó, khi bạn lập một danh sách các kịch bản để kiểm tra

def test_sum():
    assert sum([1, 2, 3]) == 6, "Should be 6"

def test_sum_tuple():
    assert sum((1, 2, 2)) == 6, "Should be 6"

if __name__ == "__main__":
    test_sum()
    test_sum_tuple()
    print("Everything passed")