[开发测试]python_unittest框架

1、什么是unittest框架?

概念:unittest是python自带的一个单元测试框架,用它来做单元测试

对于测试来说,unittest框架的作用是自动化脚本执行框架

2、为什么使用unittest框架

1.能够组织多个用例执行

2.提供丰富的断言方法

3.能够生成测试报告

3、unittest核心要素(unittest组成部分)

1.TestCase(最核心的模块):

每个TestCase(测试用例)都是一个代码文件,在这个代码文件中来书写真正的测试用例

2.TestSuite

TestSuite(测试套件),用来管理组装多个TestCase的

3.TestRunner

TestRunner(测试执行,测试运行)用来执行TestSuite的

4.TestLoader

TestLoader(测试加载),功能是对TestSuite功能的补充,管理组装多个TestCase的

5.Fixture

Fixture(测试夹具),书写在TestCase代码中,是一个代码结构,可以在每个方法执行前后都会运行的内容

4、TestCase(测试用例)

1.是一个代码文件,在代码文件中真正用来书写测试用例的

2.代码文件的名字必须按照标识符规则来书写

步骤:

1.导包

2.自定义测试类

3.在测试类中书写测试方法

4.执行代码

#1\导包
import unittest

#2\自定义测试类,继承unittest中的testcase方法
class TestDemo(unittest.TestCase):
    #3\书写测试方法,必须以test_开头
    def test_mythod1(self):
        print('测试方法1')

    def test_mythod2(self):
        print('测试用例2')
#4\执行用例
# 4.1 将光标放在类名后面运行,会执行类中的所有方法
# 4.2 将光标放在方法名的后面运行,只会执行当前方法

5、TestSuite&TestRunner

TestSuite(测试套件),用来管理组装多个TestCase的

TestRunner(测试执行)用来执行TestSuite的

步骤:

1.导包(unittest)

2.实例化(创建对象)套件对象

3.使用套件对象添加用例方法

4.实例化运行对象

5.使用运行对象去执行套件对象

# 1.导包(unittest)
import unittest
# 2.实例化(创建对象)套件对象
from hm_test1 import TestDemo1
from hm_test2 import TestDemo2

suite = unittest.TestSuite()
# 3.使用套件对象添加用例方法
#方法一:套件对象.addTest(测试类名('方法名'))
suite.addTest(TestDemo1('test_mythod1'))
suite.addTest(TestDemo1('test_mythod2'))
suite.addTest(TestDemo2('test_mythod1'))
suite.addTest(TestDemo2('test_mythod2'))
#方式二:将一个测试类中的所有方法进行添加
#套件对象.addTest(unittest.makeSuite(测试类名))
suite.addTest(unittest.makeSuite(TestDemo1))
suite.addTest(unittest.makeSuite(TestDemo2))
# 4.实例化运行对象
runner = unittest.TextTestRunner()
# 5.使用运行对象去执行套件对象
#运行对象.run(套件对象)
runner.run(suite)

6、TestLoader(测试加载)

TestLoader作用和TestSuite的作用是一样的,都是对TestSuite功能的补充,用来组装测试用例的

步骤:

1.导包

2.实例化测试加载对象并添加用例? ?----> 得到的是suite对象

3.实例化运行对象

4.运行对象执行套件对象

# 1.导包
import unittest
# 2.实例化测试加载对象并添加用例
#unittest.TestLoader().discover('用例所在的路径','用例代码的文件名')路径可以用相对路径
suite = unittest.TestLoader().discover('./case','hm*.py')
# 3.实例化运行对象
runner = unittest.TextTestRunner()
# 4.运行对象执行套件对象
runner.run(suite)


#或者
import unittest
#使用默认的加载对象并加载用例
suite = unittest.defaultTestLoader.discover('case','hm*.py')
#3 4步合一
unittest.TextTestRunner().run(suite)

7、Fixture(测试夹具)

Fixture是一种代码结构，在特定情况下会自动执行

方法级别

在每个方法（测试代码）执行前都会自动调用的结果

#方法执行前
def setUp(self):
    pass

#方法执行后
def tearDown(self):
    pass

类级别

在每个测试类中所有方法执行前后都会自动调用的结构（在整个类中前后只会执行一次）

#类级别的fixture是一个类方法

#前
@classmethod
def setUpClass(cls):
    pass

#后
def tearDownClass(cls):
    pass

模块级别（了解）

在每个代码文件执行前后执行的代码结构

案例

1.打开浏览器? ?----->类级别

2.输入网址? ?----->方法级别

3.输入用户名和密码进行登录? ?----->测试方法

4.关闭当前页面? ?----->方法级别

5.关闭浏览器? ?----->类级别

import unittest

class TestLogin(unittest.TestCase):
    def setUp(self) -> None:
        print('*'*50)

    def tearDown(self) -> None:
        print('*'*50)

    @classmethod
    def setUpClass(cls) -> None:
        print('-------打开浏览器-------')

    @classmethod
    def tearDownClass(cls) -> None:
        print('-------关闭浏览器-------')

    def test_1(self):
        print('请输入用户名')

    def test_2(self):
        print('请输入密码')

断言

让程序代替人工自动的判断预期结果与实际结果是否相符

断言的结果：

True：用例通过

False：代码抛出异常，用力不通过

在unittest中使用断言，都需要通过self.断言方法来试验

assertEqual

self.assertEqual（预期结果，实际结果）? #判断预期和实际是否相符

如果相等，用例通过；如果不相等，用力不通过，抛出异常

assertIn

self.assertIn（预期结果，实际结果）?? #判断预期是否包含在实际结果中

包含，用例通过；不包含，用例不通过

assertIn（'admin','admin'）#包含

assertIn（'admin','8862admin2233'）#包含

import unittest
from tools import login

class TestLogin(unittest.TestCase):
    def test_username_right(self):
        self.assertEqual('登录成功', login('admin', '123456'))

    def test_username_error(self):
        self.assertEqual('登录失败', login('root', '123456'))

    def test_pwd_right(self):
        self.assertEqual('登录成功', login('admin', '123456'))

    def test_pwd_error(self):
        self.assertEqual('登录失败', login('admin', '123456'))

参数化

参数化在测试方法中，使用变量来代替具体的测试数据，然后使用传参的方法将测试数据传递给方法的变量

好处：相似的代码不需要多次书写

工作中的场景：

1.测试数据一般写在json文件中

2.使用代码读取json文件，提取到我们想要的数据-------->[(),()}? or? [[],[]]

安装插件：pip install parameterized

验证：pip list? ? 看para在不在列表中

?