自学python笔记07——测试函数和类

编写函数或类时，还可为其编写测试。通过测试，可确定代码面对各种输入都能够按要求的那样工作。测试让你深信，即便有更多人使用你的程序，它也能正确地工作。在程序中添加新代码时，也可以对其进行测试，确认不会破坏程序既有的行为。

学习如何使用Python模块unittest中的工具来测试代码，还将学习编写测试用例，核实一系列输入都将得到预期的输出。你将看到测试通过了是什么样子，测试未通过又是什么样子，还将知道测试未通过如何有助于改进代码。你将学习如何测试函数和类，并将知道该为项目编写多少个测试。

测试函数

下面是一个简单的函数，它接受名和姓并返回姓名：

name_function.py

def get_formatted_name(first, last):
    """生成整洁的姓名。"""
    full_name = f"{first} {last}"
    return full_name.title()

下面程序加载name_function模块， 让用户输入名和姓，并显示姓名

name.py

from name_function import get_formatted_name
print("Enter 'q' at any time to quit.")
    while True:
        first = input("\nPlease give me a first name: ")
        if first == 'q':
            break
        last = input("Please give me a last name: ")
        if last == 'q':
            break
        formatted_name = get_formatted_name(first, last)
        print(f"\tNeatly formatted name: {formatted_name}.")

输出：

Enter 'q' at any time to quit.

Please give me a first name: liu
Please give me a last name: junlong
        Neatly formatted name: Liu Junlong.

Please give me a first name: q

现在假设要修改get_formatted_name() ，使其还能够处理中间名。这样做时，要确保不破坏这个函数处理只含有名和姓的姓名的方式。为此，可在每次修改get_formatted_name() 后都进行测试：运行程序names.py，并输入像Janis Joplin这样的姓名。不过这太烦琐了。所幸Python提供了一种自动测试函数输出的高效方式。倘若对get_formatted_name() 进行自动测试，就能始终确信当提供测试过的姓名时，该函数都能正确工作。

模块unittest

Python 标准库中的模块 unittest 提供了代码测试工具。

单元测试 用于核实函数的某个方面没有问题。

测试用例 是一组单元测试，它们一道核实函数在各种情形下的行为都符合要求。

导入模块 unittest 和要测试的函数，再创建一个继承unittest.TestCase 的类，并编写一系列方法对函数行为的不 同方面进行测试。

unittest模块中的断言方法：

Python在unittest.TestCase 类中提供了很多断言方法，断言方法检查你认为应该满足的条件是否确实满足，应该满足的条件实际上并不满足，Python将引发异常。

assertEqual(a, b) 核实a == b

assertNotEqual(a, b) 核实a != b

assertTrue(x) 核实x 为True

assertFalse(x) 核实x 为False

assertIn(item , list ) 核实 item 在 list 中

assertNotIn(item , list ) 核实 item 不在 list 中

下面的测试用例只包含一个方法，它检查函数get_formatted_name() 在给定名和姓时能否正确工作：

test_name_function.py

import unittest
from name_function import get_formatted_name
class NamesTestCase(unittest.TestCase):
    """测试name_function.py。"""
    def test_first_last_name(self):
        """能够正确地处理像Janis Joplin这样的姓名吗？"""
        formatted_name = get_formatted_name('janis', 'joplin')
        self.assertEqual(formatted_name, 'Janis Joplin')

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

这个类可以随意命名，但最好让它看起来与要测试的函数相关并包含Test 字样。这个类必须继承unittest.TestCase 类，这样 Python 才知道如何运行你编写的测试。

运行 test_name_function.py 时，所有以 test_打头的方法都将自动运行。

运行结果：

st_name_function.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

第一行的 ‘ . ’ 表明有一个测试通过了。接下来的一行指出Python运行了一个测试，消耗的时间不到0.001秒。最后的OK 表明该测试用例中的所有单元测试都通过了

下面是函数 get_formatted_name() 的新版本，它要求通过一个实参指定中间名：

def get_formatted_name(first, middle, last):
    """生成整洁的姓名。"""
    full_name = f"{first} {middle} {last}"
    return full_name.title()

执行测试用例输出：

E
======================================================================
ERROR: test_first_last_name (__main__.NamesTestCase.test_first_last_name)
能够正确地处理像Janis Joplin这样的姓名吗？
----------------------------------------------------------------------
Traceback (most recent call last):
  File "d:\pytest\alient_invasion\test_name_function.py", line 7, in test_first_last_name
    formatted_name = get_formatted_name('janis', 'joplin')
                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: get_formatted_name() missing 1 required positional argument: 'last'

----------------------------------------------------------------------
Ran 1 test in 0.001s

FAILED (errors=1)

测试未通过时，第一行输出只有一个字母 ‘E’ ，指出测试用例中有一个单元测试导致了错误。

Traceback指出get_formatted_name()这个函数少了一个参数。get_formatted_name() 以前只需要名和姓两个实参，但现在要求提供名、中间名和姓。新增的中间名参数是必不可少的，这导致get_formatted_name() 的行为不符合预期。就这里而言，最佳的选择是让中间名变为可选的。这样做后，使用类似于Janis Joplin的姓名进行测试时，测试就又能通过了，而且也可以接受中间名。下面来修改get_formatted_name()。

def get_formatted_name(first,last，middle=''):
    if middle:
        full_name = f"{first} {middle} {last}"
    else:
        full_name = f"{first} {last}"
    return full_name.title()

再次执行测试用例：

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

OK

测试通过了，确定get_formatted_name() 又能正确处理简单的姓名后，我们再编写一个测试，用于测试包含中间名的姓名。

在 NamesTestCase 类中再添加一个方法：

import unittest
from name_function import get_formatted_name
class NamesTestCase(unittest.TestCase):
    """测试name_function.py。"""
    def test_first_last_name(self):
        """能够正确地处理像Janis Joplin这样的姓名吗？"""
        formatted_name = get_formatted_name('janis', 'joplin')

    def test_first_last_middle_name(self):
        """能够正确地处理像Wolfgang Amadeus Mozart这样的姓名吗？"""
        formatted_name = get_formatted_name('wolfgang', 'mozart', 'amadeus')
        self.assertEqual(formatted_name, 'Wolfgang Amadeus Mozart')

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

输出结果：

..
----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

显示有两个单元测试pass了。

测试类

很多程序中都会用到类，因此证明你的类能够正确工作大有裨益。如果针对类的测试通过了，你就能确信对类所做的改进没有意外地破坏其原有的行为。

类的测试与函数的测试相似，你所做的大部分工作是测试类中方法的行为。不过还是存在一些不同之处，下面编写一个要测试的类。来看一个帮助管理匿名调查的类：

survey.py

class AnonymousSurvey:
    """收集匿名调查问卷的答案。"""
    def __init__(self, question):
        """存储一个问题，并为存储答案做准备。"""
        self.question = question
        self.responses = []
    def show_question(self):
        """显示调查问卷。"""
        print(self.question)
    def store_response(self, new_response):
        """存储单份调查答卷。"""
        self.responses.append(new_response)
    def show_results(self):
        """显示收集到的所有答卷。"""
        print("Survey results:")
        for response in self.responses:
            print(f"- {response}")

为证明 AnonymousSurvey 类能够正确工作，编写一个使用它的程序：

language_survey.py

from survey import AnonymousSurvey
# 定义一个问题，并创建一个调查。
question = "What language did you first learn to speak?"
my_survey = AnonymousSurvey(question)
# 显示问题并存储答案。
my_survey.show_question()
print("Enter 'q' at any time to quit.\n")
while True:
    response = input("Language: ")
    if response == 'q':
        break
    my_survey.store_response(response)
# 显示调查结果。
print("\nThank you to everyone who participated in the survey!")
my_survey.show_results()

输出结果：

What language did you first learn to speak?
Enter 'q' at any time to quit.

Language: english
Language: china
Language: q

Thank you to everyone who participated in the survey!
Survey results:
- english
- china

下面来编写一个测试，对 AnonymousSurvey 类的行为的一个方面进行验证：如果用户面对调查问题只提供一个答案，这个答案也能被妥善地存储。为此，我们将在这个答案被存储后，使用方法

assertIn() 来核实它确实在答案列表中：

test_survey.py

import unittest
from survey import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
    """针对AnonymousSurvey类的测试。"""
    def test_store_single_response(self):
        """测试单个答案会被妥善地存储。"""
        question = "What language did you first learn to speak?"
        my_survey = AnonymousSurvey(question)
        my_survey.store_response('English')
        self.assertIn('English', my_survey.responses)

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

执行结果：

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

OK

只能收集一个答案的调查用途不大。下面来核实当用户提供三个答案时，它们也将被妥善地存储。为此，在TestAnonymousSurvey 中再添加一个方法：

import unittest
from survey import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
    """针对AnonymousSurvey类的测试。"""
    def test_store_single_response(self):
        """测试单个答案会被妥善地存储。"""
        question = "What language did you first learn to speak?"
        my_survey = AnonymousSurvey(question)
        my_survey.store_response('English')
        self.assertIn('English', my_survey.responses)
    def test_store_three_responses(self):
        """测试三个答案会被妥善地存储。"""
        question = "What language did you first learn to speak?"
        my_survey = AnonymousSurvey(question)
        responses = ['English', 'Spanish', 'Mandarin']
        for response in responses:
            my_survey.store_response(response)
        for response in responses:
            self.assertIn(response, my_survey.responses)

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

执行结果：

..
----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

方法setUp()

在前面的 test_survey.py 中，我们在每个测试方法中都创建了一个AnonymousSurvey 实例，并在每个方法中都创建了答案。unittest.TestCase 类包含的方法 setUp() 让我们只需创建这些对象一次，就能在每个测试方法中使用。如果在TestCase 类中包含了方法setUp() ，Python将先运行它，再运行各个以test_打头的方法。这样，在你编写的每个测试方法中，都可使用在方法setUp() 中创建的对象。

下面使用 setUp() 来创建一个调查对象和一组答案，供方法

test_store_single_response() 和

test_store_three_responses() 使用：

import unittest
from survey import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
    """针对AnonymousSurvey类的测试。"""
    def setUp(self):
        """
        创建一个调查对象和一组答案，供使用的测试方法使用。
        """
        question = "What language did you first learn to speak?"
        self.my_survey = AnonymousSurvey(question)
        self.responses = ['English', 'Spanish', 'Mandarin']
    def test_store_single_response(self):
        """测试单个答案会被妥善地存储。"""
        self.my_survey.store_response(self.responses[0])
        self.assertIn(self.responses[0], self.my_survey.responses)
    def test_store_three_responses(self):
        """测试三个答案会被妥善地存储。"""
        for response in self.responses:
            self.my_survey.store_response(response)
        for response in self.responses:
            self.assertIn(response, self.my_survey.responses)

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

再次运行 test_survey.py

..
----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

两个测试都通过了。

测试自己编写的类时，方法 setUp() 让测试方法编写起来更容易：可在setUp() 方法中创建一系列实例并设置其属性，再在测试方法中直接使用这些实例。相比于在每个测试方法中都创建实例并设置

其属性，这要容易得多。

注意 运行测试用例时，每完成一个单元测试， Python 都打印一个字符：测试通过时打印一个句点，测试引发错误时打印一个E ，而测试导致断言失败时则打印一个 F 。这就是你运行测试用例时，在输出的第一行中看到的句点和字符数量各不相同的原因。如果测试用例包含很多单元测试，需要运行很长时间，就可通过观察这些结果来获悉有多少个测试通过了。