unittest 文档

合集下载

unittestreport用例描述

unittestreport用例描述摘要：1.unittest 报告简介2.用例描述的作用和重要性3.用例描述的基本格式4.用例描述的示例正文：1.unittest 报告简介unittest 是Python 标准库中的一个测试框架，用于编写和运行单元测试。

在unittest 中，报告是用于展示测试结果的重要组成部分，它可以让我们清晰地了解测试用例的执行情况。

2.用例描述的作用和重要性在编写测试用例时，我们需要对每个用例进行详细的描述，以便于其他人了解该用例的测试目的和预期结果。

用例描述在测试过程中起到了以下作用：- 提高测试用例的可读性：通过详细的描述，使得测试用例更容易被理解。

- 确保测试用例的正确性：描述可以帮助我们发现测试用例中可能存在的问题，提高测试质量。

- 方便沟通和协作：用例描述可以作为测试人员和开发人员之间沟通的桥梁，降低沟通成本。

3.用例描述的基本格式一个典型的用例描述包括以下几个部分：- 测试用例ID：每个测试用例都应该有一个唯一的标识符，方便在报告中进行查找。

- 测试功能：简要描述该用例要测试的功能或模块。

- 测试条件：列出该用例需要满足的前置条件。

- 测试步骤：按照顺序详细描述每个测试步骤，包括预期结果。

- 预期结果：描述测试完成后，应该看到的结果。

4.用例描述的示例假设我们要测试一个登录功能，以下是一个简单的用例描述示例：- 测试用例ID：TC001- 测试功能：测试登录功能- 测试条件：用户已注册并具备登录权限- 测试步骤：1.打开登录页面，输入正确的用户名和密码2.点击登录按钮3.预期结果：系统显示用户已成功登录，并显示用户名。

单元测试unittest及报告生成（两种报告模板）

单元测试unittest及报告⽣成（两种报告模板）Python中有⼀个⾃带的单元测试框架是unittest模块，⽤它来做单元测试，它⾥⾯封装好了⼀些校验返回的结果⽅法和⼀些⽤例执⾏前的初始化操作。

在说unittest之前，先说⼏个概念：TestCase 也就是测试⽤例TestSuite 多个测试⽤例集合在⼀起，就是TestSuiteTestLoader是⽤来加载TestCase到TestSuite中的TestRunner是来执⾏测试⽤例的,测试的结果会保存到TestResult实例中，包括运⾏了多少测试⽤例，成功了多少，失败了多少等信息1.单元测试：开发⾃⼰测⾃⼰写的代码；2.导⼊模块unittest： import unittest #导⼊unittest模块 import HTMLTestRunner #导⼊HTMLTestRunner 报告模板模块 from BeautifulReport import BeautifulReport #导⼊BeautifulReport 报告模板模块3.运⾏⼀个简单的unittest：import unittest #单元测试模块class TestCalc(unittest.TestCase):def test1(self): #函数名要以test开头，否则不会被执⾏self.assertEqual(1,1)def test2(self):self.assertEqual(1,2)unittest.main() #会运⾏当前python⽂件⾥⾯的所有测试⽤例4.unittest单元测试的基本流程：⽤例集/测试套件：存放测试⽤例的 ①.先把所有的测试⽤例都放到⽤例集 ②.运⾏这些测试⽤例 ③.产⽣报告代码：⼀.⽣成报告模板HTMLTestRunner模块（⽐较丑且相对不好⽤）注：1.安装并导⼊HTMLTestRunner 模块，该模块是可以⽣成报告的模块。

unittest单元测试框架教学

unittest单元测试框架教学（实用版）目录1.unittest 简介2.unittest 的基本使用方法3.unittest 的高级特性4.示例：使用 unittest 编写一个简单的测试用例正文1.unittest 简介unittest 是 Python 标准库中提供的一个单元测试框架，它允许用户编写自动化测试用例，以检查代码的正确性。

使用 unittest，可以轻松地为单个函数或整个模块编写测试，并生成详细的测试报告。

2.unittest 的基本使用方法（1）导入 unittest 库首先，需要在代码中导入 unittest 库。

```pythonimport unittest```（2）创建测试类接下来，创建一个继承自 unittest.TestCase 的测试类。

在这个类中，编写用于测试代码的函数。

这些函数的名称应该以“test”开头，这样 unittest 才能自动识别并执行它们。

```pythonclass TestMyFunction(unittest.TestCase):def test_add(self):self.assertEqual(add(1, 2), 3)```（3）运行测试在命令行中，使用“python -m unittest discover”命令运行测试。

其中，“discover”是 unittest 的一个命令，它会自动查找并执行所有以“test”开头的函数。

```bashpython -m unittest discover```3.unittest 的高级特性除了基本的测试功能外，unittest 还提供了许多高级特性，如：（1）设置和清理：在测试过程中，可能需要对测试环境进行设置和清理。

可以使用 setUp() 和 tearDown() 方法分别实现这两个功能。

```pythonclass TestMyDatabase(unittest.TestCase):def setUp(self):self.connection = self.create_connection()def tearDown(self):self.connection.close()def test_connection(self):self.assertIsNotNone(self.connection)```（2）测试套件和测试用例的参数化unittest 支持测试套件和测试用例的参数化，以实现更复杂的测试场景。

第7课-unittest

-- 2.用例全部是def test开头的,不要乱命名
-- 3.用例执行不需要实例化 if __name__ 下写个unittest.main()就行了，不要搞复杂了
-- 4.用例class类里面不要用def __ init__这种东西，这个是类里面的
-- 5.用例是用例，方法是方法，2个不同的概念
2.7 2.7
2.7
参考资料/post/303arm运行2种姿势
详细参考：/yoyoketang/p/7523409.html
1.以python执行运行
2.以unittest姿势运行
2.自动化用例
测试类
禅道登录
编前置条件号
操作步骤（查找元素）
用户名输入框
密码输入框
001
登录按钮
1.打开
Firefox浏览
器
用户名输入框
2.打开
密码输入框
002 http://127.0.
0.1/zentao/u 登录按钮
ser-
login.html
测试输入
admin 123456 click
功能点编号
001
登陆禅道
002
003 提交BUG
004
测试输入（操作步骤）
1.打开Firefox浏览器 2.打开 http://127.0.0.1/zentao/userlogin.html 3.输入账号：admin 4.输入密码：123456 5.点登陆按钮
1.打开Firefox浏览器 2.打开 http://127.0.0.1/zentao/userlogin.html 3.输入账号：admin1 4.输入密码：111111 5.点登陆按钮
Python单元测试框架

unittest自动化报告模板 -回复

unittest自动化报告模板-回复Unittest Automated Reporting TemplateUnittest is a popular testing framework for Python applications that allows developers to write automated tests in a straightforward and efficient manner. One of the key features of Unittest is its ability to generate comprehensive and detailed test reports. These reports provide valuable insights into the test results, making it easier for developers to identify and fix issues in their code. In this article, we will discuss the importance of automated test reporting and provide a step-by-step guide on how to generate insightful test reports using Unittest.Why Automated Test Reporting?Automated test reporting plays a crucial role in the software development lifecycle. It provides developers with timely and accurate information about the health of their codebase. Here are a few reasons why automated test reporting is important:1. Test Coverage Analysis: Test reports provide visibility into the percentage of code covered by the automated tests. This analysishelps identify areas of the code that are not adequately covered and guides developers in writing additional test cases.2. Defect Identification: Comprehensive test reports highlight failing test cases and the reasons behind the failures. This information enables developers to quickly pinpoint errors in the code and take necessary actions to fix them.3. Regression Testing: When changes are made to an application, it is essential to ensure that existing functionality is not broken. Automated test reports help in performing regression testing by identifying any unexpected changes in the behavior of the code.4. Historical Data Analysis: Test reports contain historical data, allowing developers to analyze the long-term trends in code quality and test coverage. This analysis helps in making informed decisions about code refactorings and optimizations.Now that we understand the importance of automated test reporting, let's dive into the step-by-step process of generating informative test reports using Unittest.Step 1: Writing Test CasesThe first step is to write test cases using the Unittest framework. Test cases are individual units of tests that verify the behavior of specific functionalities or classes in the code. Unittest provides various assertion methods to verify expected outcomes. It also supports setting up and tearing down resources before and after each test case.Step 2: Grouping Test CasesOrganizing test cases into logical groups or test suites makes it easier to manage and execute them. Unittest allows the creation of test suites, which are collections of test cases. These test suites can be hierarchically nested, providing a structured approach to testing.Step 3: Running TestsOnce the test cases and test suites are written, the next step is to execute the tests. Unittest provides a TestRunner class that runs the tests and generates a test report. By default, Unittest generates abasic test report showing the number of tests run, errors, and failures.Step 4: Customizing Test ReportsUnittest offers several options for customizing test reports. Developers can extend the TestRunner class and override its methods to modify the default behavior. They can choose to include additional details such as test durations, stack traces, and test output in the reports. They can also customize the formatting and layout of the reports to match their requirements.Step 5: Generating HTML ReportsWhile the default text-based reports are informative, HTML reports provide a more visually appealing and interactive representation of test results. Unittest allows developers to generate HTML reports using third-party libraries such as HTMLTestRunner or TAPTestRunner. These libraries convert the test results into HTML format, making it easier to navigate through the test reports and analyze the results.Step 6: Integration with CI/CD SystemsTo fully leverage the benefits of automated test reporting, it is essential to integrate the reporting process with Continuous Integration/Continuous Deployment (CI/CD) systems. CI/CD systems automatically trigger test executions whenever code changes are made. By integrating Unittest with CI/CD systems, developers can ensure that test reports are generated and made available whenever a new build is deployed.In conclusion, automated test reporting is a powerful tool that helps developers in monitoring the health and quality of their codebase. Unittest provides an efficient way to generate comprehensive and insightful test reports. By following the step-by-step process outlined in this article, developers can improve their testing workflows and accelerate the development process by promptly identifying and resolving bugs. With robust automated test reporting in place, developers can confidently deliver high-quality software to their users.。

unittest 综合实例

unittest 综合实例以下是一个用于展示unittest综合实例的示例代码：```pythonimport unittest# 被测试的函数def add_numbers(a, b):return a + b# 编写测试类class TestAddNumbers(unittest.TestCase):def test_add_positive_numbers(self):result = add_numbers(1, 2)self.assertEqual(result, 3)def test_add_negative_numbers(self):result = add_numbers(-1, -2)self.assertEqual(result, -3)def test_add_zero(self):result = add_numbers(0, 0)self.assertEqual(result, 0)def test_add_float_numbers(self):result = add_numbers(1.5, 2.5)self.assertAlmostEqual(result, 4.0, places=1)# 运行测试if __name__ == '__main__':unittest.main()```在上面的示例中，我们首先定义了一个简单的被测试函数`add_numbers()`，它接受两个参数并返回它们的和。

然后，我们创建了一个继承自`unittest.TestCase` 的测试类`TestAddNumbers`。

在该类中，我们编写了几个测试方法，每个方法都以`test_` 开头，用于测试`add_numbers()` 函数的不同情况。

例如，`test_add_positive_numbers()` 方法测试了两个正数相加的结果是否正确，使用了`self.assertEqual()` 断言来验证计算结果是否等于预期值。

unittest编写用例描述

unittest编写用例描述
1. 测试函数add_numbers，验证两个整数相加的结果是否正确。

输入：2, 3
预期输出：5
2. 测试函数subtract_numbers，验证两个整数相减的结果是否
正确。

输入：10, 5
预期输出：5
3. 测试函数multiply_numbers，验证两个整数相乘的结果是否
正确。

输入：4, 6
预期输出：24
4. 测试函数divide_numbers，验证两个整数相除的结果是否正确。

输入：10, 2
预期输出：5.0
5. 测试函数is_prime_number，验证给定的整数是否为素数。

输入：7
预期输出：True
6. 测试函数is_prime_number，验证给定的整数是否为素数。

输入：12
预期输出：False
7. 测试函数calculate_average，验证列表中数字的平均值是否正确。

输入：[1, 2, 3, 4, 5]
预期输出：3.0
8. 测试函数calculate_average，验证列表中数字的平均值是否正确。

输入：[2, 4, 6, 8, 10]
预期输出：6.0
9. 测试函数reverse_string，验证字符串反转是否正确。

输入："hello"
预期输出："olleh"
10. 测试函数reverse_string，验证字符串反转是否正确。

输入："unittest"
预期输出："tsetniu"。

单元测试工具UnitTest

unittest的测试运行
运行测试用例
使用python的-m参数运行unittest 模块，并指定要运行的测试用例，如 `python -m unittest test_module`
运行所有测试用例
使用`python -m unittest discover` 命令来运行当前目录下所有测试用例
03 unittest常用功能
nose是一个基于unittest的测试框架，提供了更多的功能和插件，如自动发现测试用例等。然而，unittest作为 Python的标准库之一，更加稳定和可靠。
02 unittest基本使用
unittest的安装与导入
通过pip安装unittest库：`pip install unittest`
示例：`assertFalse(False)`
assertIs
判断两个对象是否为同一个对象，如果不是则测试失败。
示例：`assertIs(a, a)`
assertIsNot
判断两个对象是否不是同一个对象，如果是则测试失败。
示例：`assertIsNot(a, b)`
05 unittest运行和调试
。
运行测试套件
使用 unittest.TextTestRunner()或 unittest.main()函数可以运行测试套件并输出结果。
测试装饰器
01
测试装饰器的概念
测试装饰器是一种特殊类型的装饰器，用于修改或增强测试用例的行为。
02 03
常用的unittest装饰器
unittest提供了一些常用的装饰器，如@unittest.skip()、 @unittest.expectedFailure()等。这些装饰器可用于控制特定测试用例的执行或修改其行为。

共享汽车测试设计unittest

共享汽车测试设计unittest一、背景介绍随着城市化的不断深入，人们对交通出行的需求也越来越高。

共享汽车作为一种新型出行方式，受到了越来越多人的青睐。

然而，由于共享汽车的特殊性质，其使用过程中也存在一些问题。

为了保证共享汽车的安全、可靠性和用户体验，需要进行测试设计。

二、测试目标1. 确保共享汽车能够正常启动、行驶和停止。

2. 检验共享汽车各项功能是否正常。

3. 测试共享汽车在不同场景下的表现。

4. 确认共享汽车的安全性和可靠性。

三、测试内容1. 启动测试：检验共享汽车启动是否正常，并确认所有仪表盘指示灯均处于正常状态。

2. 行驶测试：检验共享汽车在不同道路条件下的行驶情况，包括加速度、刹车距离等。

3. 停止测试：检验共享汽车刹车是否灵敏，并确认停止后所有系统是否处于正常状态。

4. 功能测试：检验各项功能是否正常，包括空调、音响、导航等功能。

5. 场景测试：模拟不同场景下的使用情况，包括高速公路、城市道路、山路等。

6. 安全性测试：检验共享汽车在紧急情况下的反应能力，包括刹车距离、避让能力等。

四、测试设计1. 单元测试：对共享汽车各个模块进行单独测试，确保每个模块的功能正常。

2. 集成测试：将各个模块进行集成测试，确保整体功能正常。

3. 系统测试：对整个共享汽车系统进行测试，包括启动、行驶、停止等方面。

4. 性能测试：对共享汽车在不同场景下的性能进行测试，包括加速度、刹车距离等。

5. 兼容性测试：对不同型号和品牌的共享汽车进行兼容性测试，确保用户可以无缝使用。

6. 安全性测试：对共享汽车在不同场景下的安全性进行测试，并提供相应的安全提示和措施。

五、unittest框架unittest是Python自带的一种单元测试框架。

它具有简单易用、灵活可扩展等特点。

在共享汽车的测试设计中，可以使用unittest框架来编写相应的单元测试用例。

六、示例代码1. 单元测试代码import unittestfrom car import Carclass CarTest(unittest.TestCase):def setUp(self):self.car = Car()def test_start(self):self.assertEqual(self.car.start(), "Car started.")def test_stop(self):self.assertEqual(self.car.stop(), "Car stopped.")if __name__ == '__main__':unittest.main()2. 集成测试代码import unittestfrom car import Carclass CarTest(unittest.TestCase):def setUp(self):self.car = Car()def test_start_and_stop(self):self.assertEqual(self.car.start(), "Car started.") self.assertEqual(self.car.stop(), "Car stopped.")if __name__ == '__main__':unittest.main()3. 系统测试代码import unittestfrom car import Carclass CarTest(unittest.TestCase):def setUp(self):self.car = Car()def test_start_stop_and_drive(self):self.assertEqual(self.car.start(), "Car started.")self.assertEqual(self.car.drive(50), "Driving at 50 km/h.") self.assertEqual(self.car.stop(), "Car stopped.")if __name__ == '__main__':unittest.main()。

unittest 单元测试用例

unittest 单元测试用例单元测试是软件开发中的重要环节，用于验证代码的正确性和可靠性。

通过编写一系列的测试用例，可以全面地覆盖代码的各个分支，从而保证代码的质量。

在本文中，我将介绍单元测试的概念、目的、重要性以及常见的编写方法。

一、单元测试的概念和目的单元测试是指对软件中的最小可测试单元进行验证的测试过程。

最小可测试单元通常是指函数或者方法。

单元测试的目的在于确保各个独立的单元在隔离环境下能够正常运行，与其他单元的交互不会产生意外的结果。

二、单元测试的重要性1.提高代码的可维护性：单元测试可以帮助开发人员快速定位和修复错误，提高代码的可维护性。

当新增或修改代码时，可以运行相应的单元测试用例，确保修改不会损坏原有的功能。

2.降低软件开发成本：单元测试可以早期发现和修复错误，避免错误在后续阶段扩散，从而减少修改错误所需的时间和人力成本。

3.提高软件质量：通过编写全面的单元测试用例，可以涵盖各种边界条件和异常情况，进一步提高软件的稳定性和可靠性。

4.促进团队协作：单元测试是团队协作的重要一环。

编写单元测试用例可以促进开发人员和测试人员之间的沟通和合作，更快地定位和解决问题。

三、单元测试的编写方法编写有效的单元测试用例是保证单元测试效果的关键。

下面是几个常见的编写方法：1.测试驱动开发（TDD）：测试驱动开发是一种先编写测试用例，再编写相应代码的开发方法。

通过先编写测试用例，可以更好地规划代码的实现过程，从而提高代码的质量。

2.边界条件测试：边界条件测试是指针对函数或者方法的边界条件，编写测试用例进行验证。

例如，对于一个函数计算两个整数之和，可以编写测试用例验证输入参数为最小、最大和边界值时的返回结果是否正确。

3.异常情况测试：异常情况测试是指针对函数或者方法可能抛出的异常，编写测试用例进行验证。

例如，对于一个函数从数据库中查询数据的方法，可以编写测试用例验证当数据库连接失败时，函数是否能够正确捕获异常并返回错误信息。

Python_单元测试（unittest模板）

#encoding=utf-8 import unittest import random class TestSequenceFunctions(unittest.TestCase):
def setUp(self):#初始化环境 # 初始化一个递增序列 self.seq = list(range(10)) print ("setup completed!")
def test_shuffle(self): # 随机打乱原seq的顺序 random.shuffle(self.seq) self.seq.sort() self.assertEqual(self.seq, list(range(10))) # 验证执行函数时抛出了TypeError异常 self.assertRaises(TypeError, random.shuffle, (1, 2, 3))
def test_run(self):#必须以test开头，不能带其他参数 # 从序列seq中随机选取一个元素 element = random.choice(self.seq) # 验证随机元素确实属于列表中 self.assertTrue(element in self.seq)
def test_sth(self): assert 1==1
必须以test开头不能带其他参数从序列seq中随机选取一个元素elementrandomchoiceselfseq验证随机元素确实属于列表中selfasserttrueelementinselfseqdefteststhself
Python_单元测试（ unittest模板）
单元测试（ unittest模板）
def tearDown(self):#环境清理 print ("tearDown completed")

unnittest单元测试

unnittest单元测试TestCase 的⼏个特殊⽅法：setUp():测试⽅法之前运⾏，测试前的初始化；tearDown():测试结束后运⾏，测试后的清理⼯作；setUpClass():所以测试⽅法运⾏前运⾏，单元测试的前期准备，必须使⽤@classmethod 装饰器进⾏修饰，setup()之前运⾏。

整个测试只执⾏⼀次。

tearDownClass():所以测试⽅法执⾏结束后运⾏，单元测试的清理⼯作，必须使⽤@classmethod 装饰器进⾏修饰，tearDown()之后运⾏，整个测试只执⾏⼀次。

1.加上测试集合可以批量运⾏同⼀个⽂件.py下的多个测试⽤例： Testsuitif__name__ == '__main__' :testCase1 = unittest.TestLoad().loadTestsFromTestCase(测试类名字1)testCase2 = unittest.TestLoad().loadTestsFromTestCase(测试类名字2)suit = unittest.Testsuit([testCase1,testCase2 ])unittest.TextTestRunner(verbosity=2).run(suit)备注：verbosity<=0;输出的结果不提⽰执⾏成功的⽤例数⽬；verbosity =1,输出结果仅仅以点（.）表⽰执⾏成功的⽤例数⽬；verbosity >=2,输出每个⽤例的执⾏的详细信息；TestRunner.run() 返回⼀个TestResult实⼒对象，其存放着所有测试⽤例的执⾏过程的信息，可以通过dir()⽅法查看。

.TextTestRunner.run() 以⽂本的⽅式2. 按照特定的顺序执⾏测试⽤例unittest.main()是以所有⽅法名的字符串ASCII排序执⾏，可以通过把测试⽤例添加到测试容器⾥执⾏；if __name__ = '__main__'suit =unittest.TestSuit()suit .addTest(类名("⽅法"))suit .addTest(Mytest("test_add"))suit .addTest(Mytest("test_div"))runner= unittest.TextTestRunner()runner.run(suit)3.忽略莫个测试⽅法 @unittest.skip()在测试⽅法前之前执⾏@unittest.skip(“Skipng”)⽆条件的忽略@unittest.skip(A>8，"条件不满⾜")：如果A >8，则忽略；4.命令⾏模式执⾏测试⽤例python -m unittest test_model1 test_model2python -m unittest test_model.Testclasspython -m unittest test_model.Testclass.test_method5.批量执⾏测试模块程序⽂件执⾏：if __name__ = '__main__'testsuit= unittest.TestLoad().discover('.') #加载当前⽬录下的有效的测试模块，“.”表⽰当前的⽬录；⽂件名字以test 开头unittest.TextTestRunner(verbosity=2).run(testsuit)命令⾏执⾏：python -m unittest discover #⽬录需要切换到存放脚本的⽬录下；discover 的⼀些参数：-v :输出详细的信息；-s:发现脚本的⽬录；-p:匹配莫个测试⽂件：python -m unittest discover -p "test * .py"-t:⼯程的跟⽬录下的搜索可以执⾏的测试脚本：例如：python -m unittest discover -t D:\wew\ewe6.使⽤HTML TestRunner ⽣成HTML的测试报告filename="d:\\ly.html"fp =file(filename,'wb')runner = HTML TestRunner .HTML TestRunner (stream=fp,title='Report title',description =‘Report_description’) runner.run(suit)。

unittest测试基本操作

unittest测试基本操作一、unittest中的四大金刚TestCase：测试用例，通过继承unittest.TestCase，实现用例的继承，在UnitTest中，一个testcase的实例就是一个测试用例。

测试前准备环境的搭建（setUp），执行测试代码（run），以及测试后环境的还原（tearDown），(注：测试用例都是通过开头以tes来识别的)TestSuite：测试套件，也就是上面的测试用例集TestFixture：setUp(前置条件)，tearDown(后置条件)，用于初始化测试用例以及清除和释放资源TestRunner：运行器，一般通过runner来调用suite去执行测试二、unittest的初级使用1.代码演示：# 第一步：导入unittest模块import unittest# 第二步：创建一个测试类，被继承unittest.TestCaseclass unittest_demo(unittest.TestCase):# 第三步：重写setUp和tearDown方法（如果有初始化条件和结束条件）、# 这是TestCases执行前的初始化@classmethoddef setUpClass(cls):print("TestCases Begin...")# 这是TestCases执行后的回收操作@classmethoddef tearDownClass(cls):print("TestCases End...")# 这是每个test case执行前的初始化def setUp(self):print("Begin...")# 这是每个test case执行后的测试回收def tearDown(self):print("End...")# 第四步：定义测试函数，函数名以test_开头。

测试用例def test_1(self):print("this it the first case")def test_2(self):print("this is the second case")def test_3(self):# 第四步：在函数体中使用断言来判断测试结果是否符合预期结果self.assertEqual(3, 3, msg="条件不成立")print("this is tne third case")# 第五步：调用unittset.main()方法运行测试用例--------无此方法也是可以运行if __name__ == 'main':unittest.main(verbosity=1)————————————————版权声明：本文为CSDN博主「小曹老师真可爱」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

unittest单元测试（测试报告生成）

unittest单元测试（测试报告⽣成）⾃动化测试执⾏完成之后，我们需要⽣成测试报告来查看测试结果，使⽤HTMLTestRunner模块可以直接⽣产Html格式的报告。

下载地址：下载后的修改：94⾏引⼊的名称要改，从 import StringIO 改成import io539⾏ self.outputBuffer = StringIO.StringIO() 要改成self.outputBuffer=io.StringIO()631⾏ print >>sys.stderr, '\nTime Elapsed: %s' % (self.stopTime-self.startTime)修改为：print (sys.stderr, '\nTime Elapsed: %s' %(self.stopTime-self.startTime))642⾏，if not rmap.has_key(cls): 需要换成 if not cls in rmap:766⾏的uo = o.decode('latin-1')，改成 uo=o772⾏，把 ue = e.decode('latin-1') 直接改成 ue = e注意：该修改针对的是使⽤Python3的朋友，如果你安装的是Python2，那么就不需要进⾏修改，直接使⽤即可。

存放路径：将修改完成的模块存放在Python路径下Lib⽬录⾥⾯即可案例：在前⼀篇⽂章的runtest.py的基础上进⾏修改，从⽽得到关于百度搜索的测试报告import unittestfrom HTMLTestRunner import HTMLTestRunnerimport timetest_dir = './test_case'discovery = unittest.defaultTestLoader.discover(test_dir, pattern='test*.py')if__name__ == '__main__':# 存放报告的⽂件夹report_dir = './test_report'# 报告命名时间格式化now = time.strftime("%Y-%m-%d %H_%M_%S")# 报告⽂件完整路径report_name = report_dir+'./'+now+"result.html"# 打开⽂件再报告⽂件写⼊测试结果with open(report_name, "wb") as f:runner = HTMLTestRunner(stream=f, title='百度搜索测试报告', description='⽤例执⾏结果：')# 运⾏测试⽤例runner.run(discovery)# 关闭报告⽂件f.close()代码分析：⾸先，将HTMLTestRunner模块⽤import导⼊进来其次，通过open()⽅法以⼆进制写模式打开当前⽬录下的以'当前时间+result.html'（将报告名称以当前时间命名，可以便于我们查看），如果没有，则⾃动创建该⽂件接着，调⽤HTMLTestRunner模块下的HTMLTestRunner类。

UnitTest基础、测试实例

UnitTest基础、测试实例1.四⼤组件：a.test fixture:setUp(前置条件)，tearDown(后置条件),⽤于初始化测试⽤例及清理和释放资源b.test case:测试⽤例，通过集成unittest.TestCase,来实现⽤例的继承。

在UnitTest中，测试⽤例都是通过test来识别的。

例：class forTest(unites.TestCase)；def test_xxc.test suite:测试套件，也称为测试⽤例集d.test runner:运⾏器，⼀般通过runner来调⽤suite去执⾏测试2.UnitTest运⾏机制：通过在main函数中,调⽤unittest.main()运⾏所有内容。

import unittestclass forTest(unittest.TestCase):# 类的初始化@classmethoddef setUpClass(cls) -> None:print('sClass')# 类的释放@classmethoddef tearDownClass(cls) -> None:print('tclass')# ⽤例初始化(⽤例执⾏前执⾏)def setUp(self) -> None:print('setUp')# ⽤例释放(⽤例执⾏后执⾏)def tearDown(self) -> None:print('tearDown')#函数def plus(self,a,b):print(a+b)return a+bdef test_c(self):self.plus(1,2)print('c')# 测试⽤例def test_a(self):print('a')def test_b(self):print('b')if__name__=='__main__':unittest.main(verbosity=2) # verbosity=2 让结果更细致些'''只有test_xx() 的函数才能执⾏'''打印结果：3.ddt数据驱动ddt(data-driver tests), 在实际测试中，单个测试需要⽤多种不同的条件（测试数据）对其测试。

unittest学习8unittest生成测试报告

unittest学习8unittest⽣成测试报告HTMLTestRunnerHTMLTestRunner是Python标准库的unittest模块的扩展。

它⽣成易于使⽤的HTML测试报告。

下载完成后直接放到我们代码⽂件夹中，也可以放在其他地⽅，只要我们⽤的时候，可以直接调⽤就OK下载下来后可以先看下其中代码，能否找到⼀些简单的使⽤⽅法。

（由于⽂件过⼤，这⾥我只呈现了部分我们需要⽤到的代码内容）# 输出到⽂件fp = file('my_report.html', 'wb')runner = HTMLTestRunner.HTMLTestRunner(stream=fp,title='My unit test',description='This demonstrates the report output by HTMLTestRunner.')# 使⽤外部样式表。

# 运⾏测试runner.run(my_test_suite)当然了我们只⽤这么多就可以⽣成报告了。

⼩试⽜⼑1、在unittest中编写测试⽤例这⾥我还是直接调⽤前⾯写的通⽤代码了# coding:utf-8import unittestimport requestsclass Music(unittest.TestCase):def select(self,name):url = 'https://api.apiopen.top/searchMusic'data = {"name":name}r = requests.post(url,data=data)b = r.json()['result'][0]['title']return bdef test01(self):b = '断桥残雪'a = self.select(b)self.assertEqual(b,a)print('这个是⽤例⼀')def test02(self):a = '说好不哭'b = self.select(a)self.assertEqual(a,b)print('这个是⽤例⼆')def test03(self):a = '芒种'b = self.select(a)self.assertEqual(a,b)print('这个是⽤例三')if __name__ == '__main__':unittest.main()2、添加报告路径已经报告内容通过os模块进⾏找到当前⽂件夹，使报告⽣成当前⽂件夹中# 当前⽂件夹路径report_path = os.path.dirname(os.path.realpath(__file__))# 测试报告地址report_abspath = os.path.join(report_path, "result.html")fp = open(report_abspath, "wb")runner = HTMLTestRunner_cn.HTMLTestRunner(stream=fp,title=u'⾃动化测试报告,测试结果如下：',description=u'⽤例执⾏情况：')3、批量执⾏⽤例，导⼊测试报告内容中通过unittest中执⾏⽤例的⽅法，来批量执⾏⽤例# 实例化testunit = unittest.TestSuite()# 加载⽤例testunit.addTests(unittest.TestLoader().loadTestsFromTestCase(Music))# 执⾏⽤例runner.run(testunit)4、当然是赶快执⾏查看报告内容啊通过⽤例，我们可以看到这⾥已经完全⽣成报告了。

单元测试框架Unittest

单元测试框架Unittest Unittest官⽅ 4个重要概念：Test fixture(测试固件):初始化、清除Test case(测试⽤例)，test suite(测试套件)，test runner(测试运⾏器)两种单元测试加载⽅法：1.unittest.main()2.将所有test case 添加到test suit中，然后⼀次性加载知识点：1.测试类要继承unittest.TestCase类2.每个⽤例⽅法 test开头(self)3.setUp和tearDown⽅法在每个⽤例执⾏前后都会执⾏4.unittest.main()执⾏同⼀模块内unittest⼦类所有⽅法实例被测试模块 Calc.py后续部分⽤例会引⽤此模块1# coding=utf-82class Calc(object):3def add(self, x, y, *d):4# 加法计算5 result = x + y6for i in d:7 result += i8return result910def sub(self, x, y, *d):11# 减法计算12 result = x - y13for i in d:14 result -= i15return result1617 @classmethod18def mul(cls, x, y, *d):19# 乘法计算20 result = x * y21for i in d:22 result *= i23return result2425 @staticmethod26def div(x, y, *d):27# 除法计算28if y != 0:29 result = x / y30else:31return -132for i in d:33if i != 0:34 result /= i35else:36return -137return result例⼦1 ⽤例初始化清除setUp、tearDown1#encoding=utf-82import unittest3import random4class TestSequenceFunctions(unittest.TestCase):5def setUp(self):6# 初始化⼀个递增序列7 self.seq = range(10)8print"setup completed!"910def test_run(self):11# 从序列seq中随机选取⼀个元素12 element = random.choice(self.seq)13# 验证随机元素确实属于列表中14 self.assertTrue(element in self.seq)1516def test_sth(self):17assert 1==11819def tearDown(self):20print"tearDown completed"2122class TestDictValueFormatFunctions(unittest.TestCase):23def setUp(self):24 self.seq = range(10)2526def test_shuffle(self):27# 随机打乱原seq的顺序28 random.shuffle(self.seq)29 self.seq.sort()30 self.assertEqual(self.seq, range(10))31# 验证执⾏函数时抛出了TypeError异常32 self.assertRaises(TypeError, random.shuffle, (1, 2, 3))3334if__name__ == '__main__':35 unittest.main()例⼦2 类初始化清除setUpClass(cls)、tearDownClass(cls)类⾥所有⽤例执⾏前后仅执⾏⼀次1#encoding=utf-82import unittest34# 被测试类5class myclass(object):6 @classmethod7def sum(self, a, b):8return a + b #将两个传⼊参数进⾏相加操作910 @classmethod11def sub(self, a, b):12return a - b #将两个传⼊参数进⾏相减操作131415class mytest(unittest.TestCase):16 @classmethod17def setUpClass(cls):18"初始化类固件"19print"----setUpClass"2021 @classmethod22def tearDownClass(cls):23"重构类固件"24print"----tearDownClass"2526# 初始化⼯作27def setUp(self):28 self.a = 329 self.b = 130print"--setUp"3132# 退出清理⼯作33def tearDown(self):34print"--tearDown"3536# 具体的测试⽤例，⼀定要以test开头37def testsum(self):38# 断⾔两数之和的结果是否是439 self.assertEqual(myclass.sum(self.a, self.b), 4, 'test sum fail')4041def testsub(self):42# 断⾔两数之差的结果是否是243 self.assertEqual(myclass.sub(self.a, self.b), 2, 'test sub fail')444546if__name__ == '__main__':47 unittest.main() # 启动单元测试例⼦3 按特定顺序执⾏⽤例unittest框架⽤例执⾏顺序是按照⽤例名字符的ASCII码顺序⽤例数⼩于10：可将⽤例名命名为test加0-9，按数字由⼩到⼤顺序执⾏⽤例数⼤于10：可将⽤例名字⾸字母开始命名 a-Z按顺序执⾏，如第⼀字母相同，则第⼆字母再按a-Z顺序排序，以此类推suit.addTest(class(‘testcase’)) 按此⽅式添加的⽤例会按添加顺序执⾏此代码需要⽂本开头的被测试模块Calc.py1#encoding=utf-82import unittest3from Calc import Calc45class MyTest(unittest.TestCase):67 @classmethod8def setUpClass(self):9print u"单元测试前，创建Calc类的实例"10 self.c = Calc()1112# 具体的测试⽤例，⼀定要以test开头，执⾏顺序按照字母顺序开头13def test_0add(self):14print"run add()"15 self.assertEqual(self.c.add(1, 2, 12), 15, 'test add fail')1617def test_1sub(self):18print"run sub()"19 self.assertEqual(self.c.sub(2, 1, 3), -2, 'test sub fail')2021def test_2mul(self):22print"run mul()"23 self.assertEqual(Calc.mul(2, 3, 5), 30, 'test mul fail')2425def test_3div(self):26print"run div()"27 self.assertEqual(Calc.div(8, 2, 4), 1, 'test div fail')2829if__name__ == '__main__':30 unittest.main()# 启动单元测试313233if__name__ == '__main__':34 suite = unittest.TestSuite()35 suite.addTest(MyTest(‘test_2mu’))36 suite.addTest(MyTest(‘test_1sub’))37 runner = unittest.TextTestRunner()38 runner.run(suite)例⼦4 忽略测试⽅法，不想执⾏的⽤例，可跳过unittet可以分⽆条件忽略和有条件忽略,通过装饰器实现跳过⽤例时打印括号内后⾯参数的内容(跳过原因)@unittest.skip(reason) 装饰器：⽆条件跳过装饰的测试，并说明跳过测试的原因。

unittest之makeSuitetestloaddiscover及测试报告teseReport

unittest之makeSuitetestloaddiscover及测试报告teseReport 测试套件suite除了使⽤addTest以外，还有使⽤操作起来更更简便的makeSuite\testload\discover1、makeSuite，创建测试套件，传的参数是要执⾏的测试⽤例所在的类名，如下代码makeSuite（）⾥传⼊的就是⽤例test01\test02所在的类Login,代码：reload(sys)sys.setdefaultencoding('utf-8')是将代码中的字符类型都转为UTF-8编码格式#!/usr/bin/env.python#-*-coding:utf-8-*-from selenium import webdriverimport unittestimport sysreload(sys)sys.setdefaultencoding('utf-8')class Login(unittest.TestCase):@classmethoddef setUpClass(cls):cls.driver = webdriver.Firefox()cls.driver.maximize_window()cls.driver.implicitly_wait(30)cls.driver.get('https:///')def test01(self):'''验证⽹页title是否正确'''self.assertTrue(str(self.driver.title).startswith('百度⼀下'))def test02(self):'''验证⽹址是否正确'''self.assertEqual(self.driver.current_url, 'https:///')@classmethoddef tearDownClass(cls):cls.driver.quit()@staticmethoddef suite():suite = unittest.makeSuite(Login)return suiteif __name__ == '__main__':unittest.TextTestRunner(verbosity=2).run(Login.suite())2、testload:⼀般只有这个⽅法suite=unittest.TestLoader.loadTestsFromTestCase(Login)，传⼊的也是类名#!/usr/bin/env.python#-*-coding:utf-8-*-from selenium import webdriverimport unittestclass Login(unittest.TestCase):@classmethoddef setUpClass(cls):cls.driver = webdriver.Firefox()cls.driver.maximize_window()cls.driver.implicitly_wait(30)cls.driver.get('https:///')def test01(self):'''验证⽹页title是否正确'''self.assertEqual(self.driver.title,u'百度⼀下，你就知道')def test02(self):'''验证⽹址是否正确'''self.assertEqual(self.driver.current_url, 'https:///')@classmethoddef tearDownClass(cls):cls.driver.quit()@staticmethoddef suite():suite=unittest.TestLoader.loadTestsFromTestCase(Login)return suiteif __name__ == '__main__':unittest.TextTestRunner(verbosity=2).run(Login.suite())3、discover:在实际测试中，被测试的系统肯定是多个模块，然后⼀个模块中有N条⽤例，discover就是以递归的⽅式找到制定⽬录⾥的⽂件（要被执⾏的⽤例模块⽂件，⼀般习惯都是test01.py.x的命名格式），加载在测试套件中，进⾏运⾏discover的三个参数：start_dir=os.path.join(os.path.dirname(__file__)+'/test1'),要被测试的⽂件所在的⽬录，⼀般是⽤os.path拼接pattern='test*.py'，⽤正则表达式匹配测试⽤例的⽂件名，*表⽰⼀个或多个字符，'test*.py'表⽰以test开头的，中间N个字符，以.py结束的⽂件top_level_dir=None 默认的具体代码：#!/usr/bin/env.python#-*-coding:utf-8-*-import unittestimport osdef suite():suite=unittest.defaultTestLoader.discover(start_dir=os.path.join(os.path.dirname(__file__)+'/test1'),pattern='test*.py',top_level_dir=None)return suiteif __name__=='__main__':unittest.TextTestRunner(verbosity=2).run(suite())4、断⾔assertEqual(a,b):a的值和b的值如果相等-->PASSassertTrue(a) 表达式a的结果为真，则PASS#!/usr/bin/env.python#-*-coding:utf-8-*-from selenium import webdriverimport unittestimport sysreload(sys)sys.setdefaultencoding('utf-8')class Login(unittest.TestCase):@classmethoddef setUpClass(cls):cls.driver=webdriver.Firefox()cls.driver.maximize_window()cls.driver.implicitly_wait(30)cls.driver.get('https:///')def test01(self):'''验证⽹页title是否正确'''self.assertTrue(self.driver.title.startswith('百度⼀下'))def test02(self):'''验证⽹址是否正确'''self.assertEqual(self.driver.current_url,'https:///')@classmethoddef tearDownClass(cls):cls.driver.quit()@staticmethoddef suite():suite=unittest.makeSuite(Login)return suiteif __name__=='__main__':unittest.TextTestRunner(verbosity=2).run(Login.suite())5、测试报告5.1、使⽤对象file⽣成测试报告fp=file(os.path.join(os.path.dirname(__file__)+'/TestReport.html'),'wb')拆分解释：os.path.join(os.path.dirname(__file__)+'/TestReport.html')测试报告的路径（和名称），'wb'：以⼆进制的⽅式写⼊5.2、测试执⾏runner写法如下：（测试报告需导⼊import HTMLTestRunner）runner=HTMLTestRunner.HTMLTestRunner(stream=fp,title=u'报告的标题TestReport',description=u'报告的描述')HTMLTestRunner的三个参数：stream=fp 指定测试报告是哪个⽂件title=u'报告的标题TestReport',测试报告的标题description=u'报告的描述'测试报告的描述具体代码：#!/usr/bin/env.python#-*-coding:utf-8-*-import os,sysimport unittestimport HTMLTestRunnerreload(sys)sys.setdefaultencoding('utf-8')def suite():suite=unittest.defaultTestLoader.discover(start_dir=os.path.join(os.path.dirname(__file__)+'/test1'),pattern='test*.py',top_level_dir=None)return suiteif __name__=='__main__':fp=file(os.path.join(os.path.dirname(__file__)+'/TestReport.html'),'wb')runner=HTMLTestRunner.HTMLTestRunner(stream=fp,title=u'报告的标题TestReport',description=u'报告的描述')runner.run(suite())测试报告：右击在浏览器打开testReport.html,截图如下注意：每个⽤例要测的是什么的描述必须要写，要不然测试报告中没有测试⽤例冒号：后的⽂字，就不知道哪个⽤例是测什么功能点的。

unittest收集用例

unittest收集用例unittest收集用例指的是使用Pythonunittest框架来收集测试用例，以进行自动化测试。

在使用unittest进行自动化测试时，我们需要编写测试用例，然后使用unittest框架来运行这些测试用例。

unittest框架提供了很多方法来收集测试用例，其中最常用的方法是使用TestLoader类中的discover()方法。

discover()方法可以自动从指定目录中查找测试用例，并自动加载这些测试用例。

使用discover()方法时，需要指定测试用例所在的目录以及测试用例文件名的匹配规则。

例如，我们可以使用以下代码来查找当前目录下所有以test开头的.py文件中的测试用例：```pythonimport unittestimport osdef get_tests():cur_dir = os.path.abspath(os.path.dirname(__file__))pattern = 'test*.py'test_loader = unittest.TestLoader()test_suite = test_loader.discover(start_dir=cur_dir, pattern=pattern)return test_suite```上述代码中，我们首先获取当前脚本所在的目录，然后使用discover()方法来查找测试用例。

使用get_tests()函数可以获取一个包含所有测试用例的测试套件，然后我们可以使用unittest框架提供的其他方法来执行这些测试用例。

除了使用discover()方法来查找测试用例外，我们还可以手动创建测试用例，并将这些测试用例添加到测试套件中。

例如，我们可以使用以下代码来手动创建一个测试用例，并将其添加到测试套件中： ```pythonclass TestStringMethods(unittest.TestCase):def test_upper(self):self.assertEqual('foo'.upper(), 'FOO')if __name__ == '__main__':suite = unittest.TestSuite()suite.addTest(TestStringMethods('test_upper'))unittest.TextTestRunner().run(suite)```上述代码中，我们首先创建了一个名为TestStringMethods的测试用例类，并在其中定义了一个test_upper()方法。