软件测试——Python和UnitTest框架

一、软件测试

1.测试计划和测试方案

1.测试计划(管理类型文档)

(1)测试目标与范围：
(2)测试角色和职责：
(3)测试进度与资源：
(4)测试风险预估及对应措施：
(3)准入准出标准：

2.测试方案(技术型文档)

(1)测试方法策略：
(2)测试环境要求：
(3)测试工具选择：

2.非功能测试设计

(1)兼容性测试： 软件兼容其他硬件的能力。（版本，设备分辨率）
(2)易用性测试： 是否方便用户，易用易理解。
(3)性能测试： 软件对应系统时间和空间的耗费程度。（首次加载时间，刷新白屏时间，设备CPU和内存耗费比例）
(4)弱网测试： 网络切换。（WiFi网络，移动网络，网络切换正常使用）

3.测试报告

1.核心内容

(1)测试过程回顾
(2)测试统计分析
(3)测试结果确认
(4)测试总结改进

4.处理测试过程中出现不可复现的bug

(1)思考差异，测试步骤，测试账号，测试网络，测试环境。
(2)通过换电脑或环境进行测试复现，借助抓包工具，数据库等。
(3)找高级测试人员、开发人员协助复现。
(4)开发人员协助打印调试日志
(5)版本问题

二、Python

1.常用语法

1.切片

获取字符串中某些字符

字符串[start:end:step]
#start:开始位置下标
#end:结束位置下标，不包括该位置
#step:步长，默认1，可省略
#反转/逆置字符串：字符串[::-1]

2.字符串查找方法：find()

(1)在字符串中查找特定字符串

字符串.find(sub_str,start,end)
#sub_str：要查找的字符串
#start：开始位置，默认0，可省略
#end:结束位置，默认len(),可省略

**(2)返回值：**第一次出现的下标，没有找到则为-1。

3.字符串替换方法：replace()

字符串.replace(old_str,new_str,count)
#old_str：被替换的内容
#new_str：替换为的内容
#count：替换次数，默认全部

返回值: 替换后的字符串，原字符串不变。

4.字符串拆分方法：split()

将一个字符串分为多个，存到列表中。

字符串.split(sep,maxsplit=n)
#sep：分隔符，默认空白字符（空格、换行:\n,tab键:\t）
#maxsplit=n:n为分隔次数，默认全部，可省略

5.字符串链接方法：join()

将字符串插入到列表每个相邻数据之间，组成一个新的字符串。

字符串.join(列表) 
#主要是列表，也可以为其他容器
#列表中数据使用逗号隔开
#列表中数据必须是字符串，否则报错

6.列表照片查找数据下标的方法：index()

列表中无find方法。

列表.index(数据,start,end)
#返回值为第一次出现的下标，没有找到直接报错

7.判断容器中某个数据是否存在：in

数据 in 容器
#存在返回True,不存在返回False

8.字符串比大小

根据ASCII
(1)获取字符对应ASCII值

ord(字符)

(2)获取对应的字符

chr(ASCII值)

2.列表

1.统计出现次数：count()

列表.count(数据)
#返回值：数据出现次数

2.添加数据-尾部添加：append()

列表.append(数据)
#返回:None(关键字，空)

3.添加数据-指定下标位置：insert()

列表.insert(下标，数据)
#如果指定位置原来有数据，原数据将后移
#返回:None(关键字，空)

4.列表合并：extend()

列表1.extend(列表2)
#将列表2中所有数据逐个添加到列表1的尾部
#返回:None(关键字，空)

5.删除-根据下标：pop()

列表.pop(下标)
#下标不写，默认删除最后一个数据
#返回：删除的数据

6.删除-根据数据值：remove()

列表.remove(数据值)
#如果删除的数据不存在，则报错
#返回：None

7.删除-清空：clear()

列表.clear()

8.反转/倒置

#方法1:会得到一个新列表，原列表不会改变
列表[::-1]
#方法2：直接修改原列表，返回None
列表.reverse()

9.排序

列表.sort()
#默认升序

列表.sort(reverse=True)
#降序

10.去重

# 1.遍历列表
#2.使用set(自动去重)：列表->set->list

3.元组

1.可以存放任意类型的数据
2.可以存放任意多个数据

1.与列表的区别

元组中数据内容不能改变，
元组使用(),

4.字典

1.由键值对组成，{key:value,key:value,…}
2.键是唯一的，不可重复
3.键不可以是列表，一般为字符串、数字。

1.删除

#删除指定键值对
del 字典[键]
#清空
字典.clear()

2.查询

#返回值：存在则返回对应的数据值，否则报错。
字典[键]

#返回值：存在则返回对应的数据值，否则返回括号中书写的数据值(None)
#数据值默认None，可省略
字典.get(键,数据值)

3.遍历

(1)对键：

for key in 字典:
     print(key)

#字典.keys()可获取字典中的所有值
for key in 字典.keys():
     print(key)

(2)对值：

for value in 字典.values():
     print(value)

(3)对键值对:

for key,value in字典.items():
      print(key,value)

5.容器总结

1.加法运算

#字符串、列表、元组支持
#'hello world'
str1='hello'+'world'
#[1,2,3,4]
list1=[1,2]+[3,4]
#(1,2,3,4)
tuple1=(1,2)+(3,4)

2.乘法运算

#字符串、列表、元组支持
#'hello hello'
'hello' * 2
#[1,2,1,2]
[1,2] * 2
#(1,2,1,2)
(1,2) * 2

3.len()、in都可以使用

in在字典中是判断键是否存在

6.函数

def 函数名():
    代码
#查看：Ctrl q
#转到函数声明查看：Ctrl b/Ctrl+鼠标右键

7.可变和不可变类型

(1)是指数据所在内存是否允许修改，可修改为可变类型。(不使用=,变量引用数据内容改变为可变类型)
(2)可变类型:list，dict，set
(3)不可变类型：int，float、bool、str、tuple

8.多值参数[可变参数/不定长参数]

1.元组

(1)在普通参数前加上一个 * —>不定长位置参数
(2)不定长位置参数要写在普通参数的后面
(3)名字一般为args(arguments)，即 *args

2.字典

(1)在普通参数前加上两个 * —>不定长位置参数
(2)不定长位置参数要写在普通参数的后面
(3)名字一般为kwargs(keyword arguments)，即 **kwargs

3.参数顺序

def 函数名(普通函数,*args,缺省参数,**kwargs):

9.匿名函数

lambda 参数:一行代码
#变量=lambda 参数:一行代码
#使用变量()进行调用


#例子：求两个数的乘积
变量=lambda a,b:a * b

10.类

1.__init__方法

(1)适用：
1.给对象添加属性（初始方法、构造方法）。
2.在每次创建对象后都要执行的代码。
(2)创建对象后会自动调用。

(3)例子

#定义添加属性方法
def __init__(self,name,age):
    self.name=name
    self.age=age

2.__str__方法

(1)适用：
1.打印对象时想要查看的信息，一般书写对象的属性信息。
2.类中没定义__str__方法，print(对象)，默认输出对象的引用地址
(2)使用print(对象)打印对象时自动调用
(3)必须返回一个字符串

3.__del__方法

对象被删除销毁时自动调用。(析构方法)

4.类方法

#在方法名字的上方书写@classmethod修饰器
class D:
    @classmethod
    def func(cls): #cls表示类的对象,即class
        pass

5.静态方法

#在方法名字的上方书写@staticmethod修饰器
class D:
    @staticmethod
    def func():
        pass

11.文件

1.打开文件:open()

open(file,mode='r',encoding=None)

参数file: 要打开的文件，类型为字符串。路径可以是相对路径(相对于当前代码文件说在路径：./ …/),也可以是绝对路径(从根目录开始书写)。
参数mode: r:只读打开，w:只写打开，a：追加打开，在文件末尾写入内容。
参数encoding: utf-8:将一个汉字转换为3个字节的二进制，gbk:将汉字转换为2个字节的二进制。
返回值： 文件对象

2.打开文件:with open()

#在缩进中读写文件，执行结束后文件会自动关闭
with open(file,mode,encoding='utf-8') as 变量
#与open的区别：文件会自动进行关闭
#mode为a时：文件不存在则自动创建文件，存在时在末尾写入

3.写文件

文件对象.write('写入文件的内容')
#前置条件:文件打开方式是w或者a
#返回值:写入文件的字符数
#在w方式下:文件不存在将会直接创建文件，文件存在则覆盖原文件

4.读文件:read()

文件对象.read(n)
#前置条件:文件打开方式是r
#参数n:表示读取多少个字符，默认全部内容
#返回值:读取到的文件内容，类型为字符串

5.读文件:readline()

一次读取一行内容

文件对象.readline()

6.关闭文件

文件对象.close()
#同时会保存文件

12.json文件

1.概念

1.文件后缀：.json
2.主要数据类型为对象和数组(类似字典{}和列表[])。
3.对象是由键值对组成，每个数据之间用逗号隔开。
4.字符串必须使用双引号。

2.读取文件

#1.导包
import json
#2.打开文件
with open() as 变量:
#3.读文件
json.load(文件对象)

3.写文件

#1.导包
#2.以写(w)方式打开文件
#3.写入
json.dump(数据类型，文件对象)

13.异常

程序遇到异常默认终止代码，使用异常捕获，代码不会终止运行。

1.异常捕获

#捕获任意异常
try:
    可能发生异常的代码
except:
    发生了异常执行的代码

#捕获特定异常
try:
    可能发生异常的代码
except 异常类型:
    发生了异常执行的代码

#完整版本
try:
    可能发生异常的代码
except异常类型1:
    发生了异常类型1执行的代码
except Exception as 变量:
    发生其他类型异常的执行代码
else: 
    没有发生异常会执行的代码
finally:
    无论是否发生异常都会执行的代码

14.模块和包

1.导入模块

方式1：

import 模块名
模块名.工具名 #使用方法

方式2：

from 模块名 import 工具名
工具名   #使用方法，如果是函数和类需要加括号

方式3：

#将模块中所有内容都导入
from 模块名 import *

2. __name__的作用

1.每个代码文件都是一个模块
2.在导入模块时，会执行模块中的代码
3.__name__变量
(1)是python解释器自动维护的变量
(2)如果代码直接运行，值是"__main__"
(3)如果代码是被导入执行，值是模块名(即文件代码名)

三、UnitTest框架

是Python自带的一个单元测试框架。

1.TestCase(测试用例)

每个TestCase都是一个代码文件，在这个代码文件中来书写用例代码。
步骤：

#1.导包(unittest)
import unittest
#2.自定义测试类(继承unittest模块中的TestCase类)
class TestDemo(unittest.TestCase):
#3，在测试类中书写测试方法(必须以test_开头)
     def test_method1(self):
         代码
#4.执行测试用例
#4.1将光标放在类目后面运行，会执行类中所有测试方法
#4.3将光标放在方法名的后面运行，只执行当前的方法

2.TestSuite(测试套件)

用来管理、组装（打包）多个TestCase。

3.TestRunner(测试执行，测试运行)

用来执行TestSuite。
TestSuite和TestRunner的使用:

#1.导包(unittest)
import unittest
from 文件名 import 类名
#接TestCase中代码：from 文件名 import TestDemo

#2.实例化（创建对象）套件对象
suite=unnitest.TestSuite()

#3.使用套件对象添加用例方法
#方法1：套件对象.addTest(测试类名('方法名'))
suite.addTest(TestDemo(test_menthod1))
#方法2：将一个测试类中的所有方法进行添加，缺点是makeSuit()不会提示
suite.addTest(unittest.makeSuite(TestDemo))

#2.实例化运行对象
runner=unittest.TextTestRunner()

#5.使用运行对象去执行套件对象:运行对象.run(套件对象)
runner.run(suite)

4.TestLoader(测试加载)

对TestSuite功能的补充。
步骤：

#1.导包
#2.实例化测试加载对象并添加用例->得到的是suite对象
#用例代码文件名可以使用*通配符
suite=unitttest.TestLoader().discover('用例所在路径','用例的代码文件名')

#3.实例化运行对象
runner=unittest.TextTestRunner()
#4.运行对象执行套件对象
runner.sun(suite)

5.Fixture(测试夹具)

书写在TestCase代码中，是一个代码结构，可以在每个方法执行前后都会执行的内容。
(1)方法级别：
在每个测试方法执行前后都会自动调用。

#方法执行之前
def setUp(self):
    每个测试方法执行之前都会执行
    pass
#方法执行之后
def tearDown(self):
    每个测试方法执行之后都会执行
    pass   

(2)类级别：
在每个测试类中所以方法执行前后都会自动调用。(在整个类中执行前后各一次)

#类中所有方法之前
@classmethod
def setUpClass(cls):
    pass
#类中所有方法之后
@classmethod
def tearDownCalss(self):
    pass   

(3)模块级别：
在每个代码文件执行前后执行的代码结构。需要写在类的外边直接定义函数，

#代码文件之前
def setUpModule():
    pass
#代码文件之后
def tearDownModule():
    pass   

6.断言

7.参数化

使用变量来代替具体的测试数据，然后使用传参的方法将测试数据传递给方法的变量。
(1)安装插件:

#在cmd中联网安装
pip install parameterized
#验证:输入后可以看到parameterized
pip list

(2)参数化代码：

#1.导包
import unittest
from parameterized import parameterized
#2.定义测试类(以登录为例)
class TestLogin(unittest.TestCase):
#3.书写测试方法
      @parameterized.expand(数据变量)
      #数据要和参数要保存一致
      def test_login(self,username,password,expect):
          self.assertEqual(expect,login(username,password)) 
#组织测试数据并传参

8.跳过

#直接将测试函数标记成跳过
@unittest.skip('跳过原因')
#根据条件判断测试函数是否跳过
@unittest.skipIf(判断条件,'跳过原因')

9.测试报告

(1)PyCharm自带的测试报告：
只有单独运行的TestCase的代码才会生成测试报告。
(2)生成第三方的测试报告：(HTMLRunner)

注

内容来自黑马自动测试教程