Unit testing is the basis for building reliable software. There are many types of tests, but unit testing is the most important. Unit testing allows you to feel assured that you have fully tested snippets of code as basic units and rely on them when building your program. They extend your reserves of trusted code beyond the scope of language built-in features and standard libraries. In addition, Python provides strong support for writing unit tests.

Running example

Before we dive into all the principles, heuristics, and guides, let's take a look at a practical unit test example.

Create a new directory called python_tests and add two files:

• car.py
• test_car.py

Set the directory as a Python package by adding the init.py file. The structure of the file should be as follows:

<code>python_tests/
        -__init__.py
        - car.py
        - test_car.py</code>

car.py file will be used to write the logic of the self-driving car program we use in this example, and the test_car.py file will be used to write all tests.

car.py file content:

class SelfDrivingCar:
    def __init__(self):
        self.speed = 0
        self.destination = None

    def _accelerate(self):
        self.speed += 1

    def _decelerate(self):
        if self.speed > 0:
            self.speed -= 1

    def _advance_to_destination(self):
        distance = self._calculate_distance_to_object_in_front()
        if distance < 1:  # 假設(shè)距離單位為米
            self.stop()
        elif distance < 5:
            self._decelerate()
        elif self.speed < self._get_speed_limit():
            self._accelerate()

    def _has_arrived(self):
        pass  # 需要實(shí)現(xiàn)到達(dá)目的地判斷邏輯

    def _calculate_distance_to_object_in_front(self):
        pass  # 需要實(shí)現(xiàn)計(jì)算前方物體距離的邏輯

    def _get_speed_limit(self):
        pass  # 需要實(shí)現(xiàn)獲取速度限制的邏輯

    def stop(self):
        self.speed = 0

    def drive(self, destination):
        self.destination = destination
        while not self._has_arrived():
            self._advance_to_destination()
        self.stop()

This is a unit test for the TestCase class. Get the unittest module as shown below.

from unittest import TestCase

You can then override the unittest.main module provided by the unittest test framework by adding the following test script at the bottom of the test file.

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

Continue and add the test script at the bottom of the test_car.py file as shown below.

import unittest
from car import SelfDrivingCar

class SelfDrivingCarTest(unittest.TestCase):
    def setUp(self):
        self.car = SelfDrivingCar()

    def test_stop(self):
        self.car.speed = 5
        self.car.stop()
        self.assertEqual(0, self.car.speed)
        self.car.stop()
        self.assertEqual(0, self.car.speed)

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

To run the test, run the Python program:

python test_car.py

You should see the following output:

<code>test_stop (__main__.SelfDrivingCarTest) ... ok

----------------------------------------------------------------------
Ran 1 test in 0.000s

OK</code>

Test discovery

The other method, and the easiest method, is to test discovery. This option is only added in Python 2.7. Prior to 2.7, you could use nose to discover and run tests. Nose has other advantages, such as running test functions without creating classes for test cases. But for this article, let's stick with unittest.

As the name suggests, -v logo:

SelfDrivingCarTest.

There are several signs to control the operation:

python -m unittest -h

Test coverage

Test coverage is an area that is often overlooked. Coverage is how much code your test actually tests. For example, if you have a function with an if statement, you need to write a test to override the true and false branches of the if statement. Ideally, your code should be in a package. The tests for each package should be in the sibling directory of the package. In the test directory, a file named unittest module should be provided for each module of the package.

Conclusion

Unit testing is the basis of reliable code. In this tutorial, I explore some principles and guidelines for unit testing and explain several reasons behind best practices. The bigger the system you build, the more important unit testing is. But unit testing is not enough. Large systems also require other types of tests: integration testing, performance testing, load testing, penetration testing, acceptance testing, etc.

This article has been updated and contains contributions from Esther Vaati. Esther is a software developer and contributor to Envato Tuts.

The above is the detailed content of Write Professional Unit Tests in?Python. For more information, please follow other related articles on the PHP Chinese website!