随便写点东西，有的是网上借鉴，有的是自己体会，总之都是根据自己的需求进行优化的一些东西，随笔备忘录
接口框架python3+requests+unittest+HTMLTestRunner，其实与UI自动化框架python3+selenium+unittest+HTMLTestRunner相类似，这里的思路，能不能在这个接口框架中加入Excel，
实现python3+requests+excel，试一下
封装请求方式
import requests
import json
class RunMethod:
def post_main(self,url,data,header=None):
res = None
if header !=None:
res = requests.post(url=url,data=data,headers=header,verify=False).json()
else:
res = requests.post(url=url,data=data,verify=False).json()
#print(res.status_code)
return res
def get_main(self,url,data=None,header=None):
res = None
if header !=None:
res = requests.get(url=url,data=data,headers=header,verify=False)
else:
res = requests.get(url=url,data=data,verify=False)
#print(res.status_code)
return res.json()
def run_main(self,method,url,data=None,header=None):
res = None
if method == 'post':
res = self.post_main(url,data,header)
else:
res = self.get_main(url,data,header)
return json.dumps(res,ensure_ascii=False,sort_keys=True,indent=2)
封装读取表格
class global_val:
#case_id,获取表格常量
case_id = '0'
Modular = '1'
url = '2'
run = '3'
request_way = '4'
header = '5'
case_depend = '6'
data_depend = '7'
field_depend = '8'
data = '9'
expect = '10'
result = '11'
#获取caseid
def get_id():
return global_val.case_id
#获取模块
def get_modular():
return global_val.Modular
#获取url
def get_url():
return global_val.url
#获取run
def get_run():
return global_val.run
#获取请求方式
def get_request_way():
return global_val.request_way
#获取header
def get_header():
return global_val.header
#case依赖
def get_case_depend():
return global_val.case_depend
#依赖的返回数据
def get_data_depend():
return global_val.data_depend
#依赖数据所属字段
def get_field_depend():
return global_val.field_depend
#请求数据
def get_data():
return global_val.data
#预期结果
def get_expect():
return global_val.expect
#实际结果
def get_result():
return global_val.result
封装处理数据依赖
#主要处理所有数据依赖的相关问题
from util.Open_Excel import Open_Excel
from base.run_method import RunMethod
from data.get_data import GetData
from jsonpath_rw import jsonpath,parse
import json
import sys
sys.path.append('D:/PycharmProjects/Interface')
class DependentData:
def __init__(self,case_id):
self.case_id = case_id
self.op_excel = Open_Excel()
self.data = GetData()
#通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.op_excel.get_rows_data(self.case_id)
return rows_data
#执行依赖测试，获取结果
def run_dependent(self):
run_method = RunMethod()
row_num = self.op_excel.get_row_num(self.case_id)
request_data = self.data.get_data_for_json(row_num)
header = self.data.is_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_url(row_num)
res = run_method.run_main(method,url,request_data,header)
return json.loads(res)#返回数据是字符串需要转成json格式方便后续查询
#根据依赖的key去获取执行依赖测试case的响应，然后返回
def get_data_for_key(self,row):
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
return [math.value for math in madle][0]
获取数据封装
#获取数据
from util.Open_Excel import Open_Excel
from data import data_config
from util.Open_Json import Open_Json
from util.connect_db import Open_Mysql
class GetData:
def __init__(self):
self.op_excel = Open_Excel()
#获取excel行数，就是所说的case个数
def get_case_linse(self):
return self.op_excel.get_lines()
#获取是否执行
def get_is_run(self,row):
flag = None
col = int(data_config.get_run())
run_model = self.op_excel.get_cell_value(row,col)
if run_model == 'yes':
flag = True
else:
flag = False
return flag
#获取header
def is_header(self,row):
col = int(data_config.get_header())
header = self.op_excel.get_cell_value(row,col)
if header != '':
return header
else:
return None
#获取请求方式
def get_request_method(self,row):
col = int(data_config.get_request_way())
request_method = self.op_excel.get_cell_value(row,col)
return request_method
#获取url
def get_url(self,row):
col = int(data_config.get_url())
url = self.op_excel.get_cell_value(row,col)
return url
#获取请求数据
def get_request_dara(self,row):
col = int(data_config.get_data())
data = self.op_excel.get_cell_value(row,col)
if data == '':
return None
return data
#通过获取关键字拿到data数据
def get_data_for_json(self,row):
op_json = Open_Json()
request_data = op_json.get_data(self.get_request_dara(row))
return request_data
#获取预期结果
def get_expcet_data(self,row):
col = int(data_config.get_expect())
expect = self.op_excel.get_cell_value(row,col)
if expect == '':
return None
return expect
#通过sql获取预期结果
def get_expcet_data_for_mysql(self,row):
op_mysql = Open_Mysql()
sql = self.get_expcet_data(row)
res = op_mysql.search_one(sql)
return res.decode('unicode-escape')
#获取需要写入数据的实际结果的值
def write_result(self,row,value):
col = int(data_config.get_result())
self.op_excel.write_value(row,col,value)
#获取依赖数据的key
def get_depend_key(self,row):
col = int(data_config.get_data_depend())
depend_key = self.op_excel.get_cell_value(row,col)
if depend_key == "":
return None
else:
return depend_key
#判断是否有case依赖
def is_depend(self,row):
col = int(data_config.get_case_depend())
depend_case_id = self.op_excel.get_cell_value(row,col)
if depend_case_id == "":
return None
else:
return depend_case_id
#获取数据依赖字段
def get_deoend_field(self,row):
col = int(data_config.get_field_depend())
data = self.op_excel.get_cell_value(row,col)
if data == "":
return None
else:
return data
保存cookie的.json文件
测试用例表格文件
请求数据json文件
封装断言
import json
import operator
#通用的工具
class CommonUtil:
def is_contain(self, str_one, str_two):
'''
判断一个字符串是否再另外一个字符串中
str_one:查找的字符串
str_two：被查找的字符串
'''
if str_one in str_two:
flag = True
else:
flag = False
return flag
def is_equal_dict(self, dict_one, dict_two):
'''
判断两个字典是否相等
'''
if isinstance(dict_one, bytes):
dict_one = json.loads(dict_one)
if isinstance(dict_two, bytes):
dict_two = json.loads(dict_two)
return operator.eq(dict_one, dict_two)
#比较字典函数是否相等
def get_cmp_dict(self,src_data,dst_data):
if isinstance(src_data,str):
src_data=json.dumps(src_data)
if isinstance(dst_data,str):
dst_data=json.dumps(dst_data)
if len(src_data) != len(dst_data):
return False
else:
src_key=list(src_data.keys())
dst_key=list(dst_data.keys())
if operator.eq(src_key,dst_key):
src_val=list(src_data.values())
dst_val=list(dst_data.values())
if operator.eq(src_val,dst_val):
for key in src_data.keys():
if src_data[key] != dst_data[key]:
# print(src_data1[key])
return False
return True
else:
return False
else:
return False
# 比较字典函数是否包含
def get_contain_dict(self, src_data, dst_data):
if isinstance(src_data, str):
src_data = json.dumps(src_data)
if isinstance(dst_data, str):
dst_data = json.dumps(dst_data)
else:
src_key = list(src_data.keys())
dst_key = list(dst_data.keys())
# print(str(src_key))
# print(str(dst_key))
pd = [False for c in src_key if c not in dst_key]
if pd:
return False
else:
src_val = list(src_data.values())
dst_val = list(dst_data.values())
pds = [False for c in src_val if c not in dst_val]
if pds:
return False
else:
return True
封装数据库
class Open_Mysql:
def __init__(self):
self.connect = MySQLdb.connect(
host='lohost',#数据库地址
port=1234,#端口号
user='book',#数据库名字
password='123456',#数据库密码
db='oistudt',#哪个库
charset='utf8',#连接格式utf8
cursorclass=MySQLdb.cursors.DictCursor
)
self.conn = self.connect.cursor()
#查询一条数据
def search_one(self,sql):
self.conn.execute(sql)
result = self.conn.fetchone()
result = json.dumps(result)
return result
操作表格
import xlrd
from xlutils.copy import copy
#读取excel的内容
class Open_Excel:#定义打开文档的类
def __init__(self,file_name=None,sheet_id=None):
#构造函数,需要传文件name和工作表id，默认为空的情况
if file_name:
self.file_name = file_name
self.sheet_id = sheet_id
else:
self.file_name = '..\dataconfig\excelfile.xls'
self.sheet_id = 0 #默认
self.data = self.get_data()
#获取sheet的内容
def get_data(self):
data = xlrd.open_workbook(self.file_name)
tables = data.sheets()[self.sheet_id]
return tables
#获取单元格的行数
def get_lines(self):
tables = self.data
return tables.nrows
#获取某一个单元格的内容
def get_cell_value(self,row,col):
return self.data.cell_value(row,col)
#写入数据
def write_value(self,row,col,value):
read_data = xlrd.open_workbook(self.file_name)#先读到所要写入数据的excel
write_data = copy(read_data)#对这个excel进行复制
sheet_data = write_data.get_sheet(0)#对复制的excel进行操作
sheet_data.write(row,col,value)#写入数据
write_data.save(self.file_name)#保存excel
#根据对应的caseid找到对应行的内容
def get_rows_data(self,case_id):
row_num = self.get_row_num(case_id)
rows_data = self.get_row_values(row_num)
return rows_data
#根据对应的caseid找到对应的行号
def get_row_num(self,case_id):
num = 0
cols_data = self.get_cols_data()
for col_data in cols_data:
if case_id in col_data:
return num
num = num+1
#根据行号找到该行内容
def get_row_values(self,row):
tables = self.data
row_data = tables.row_values(row)
return row_data
#获取某一列的内容
def get_cols_data(self,col_id=None):
if col_id != None:
cols = self.data.col_values(col_id)
else:
cols = self.data.col_values(0)
return cols
if __name__ == '__main__':
opers = Open_Excel()
print(opers.get_data().nrows)#获取sheet内容
print(opers.get_lines())#获取单元格行数
print(opers.get_cell_value(1,3))#获取某一个单元格内容
读取header
import requests
import json
from util.Open_Json import Open_Json
class OpenHeader:
def __init__(self, response):
self.response = json.loads(response)
def get_response_url(self):
'''
获取登录返回的token的url
'''
url = self.response['data']['url'][0]
return url
def get_cookie(self):
'''
获取cookie的jar文件
'''
url = self.get_response_url() + "&callback=jQuery21008240514814031887_1508666806688&_=1508666806689"
cookie = requests.get(url).cookies
return cookie
def write_cookie(self):
cookie = requests.utils.dict_from_cookiejar(self.get_cookie())#把jar转化成字典
op_json = Open_Json()
op_json.write_data(cookie)
操作json文件
class Open_Json:
def __init__(self,file_path=None):
if file_path == None:
self.file_path = '../dataconfig/login.json'
else:
self.file_path = file_path
self.data = self.read_data()
#读取json文件
def read_data(self):
with open(self.file_path,encoding='utf-8') as fp:
data = json.load(fp)
return data
#根据关键字获取数据
def get_data(self,id):
#print(type(self.data))
return self.data[id]
#写json
def write_data(self,data):
with open('../dataconfig/cookie.json','w') as fp:
fp.write(json.dumps(data))
邮件封装
import smtplib
from email.mime.text import MIMEText
class SendEmail:
global send_user#生成一个全局变量
global email_host#生成邮件传送服务器变量
global password
send_user = "gp321111116@163.com"#给这个全局变量赋值
email_host = "smtp.163.com"#简单邮件传送协议服务器地址
password = "gp31111111186"#授权码，注意不是邮箱登录密码，是授权密码！！！
def send_mail(self,user_list,sub,content):
user = "gg"+"<"+send_user+">"#发件人+发件人邮箱
message = MIMEText(content,_subtype='plain',_charset='utf-8')#内容，格式，编码
message['Subject'] = sub#邮件主题
message['From'] = user #邮件来自于谁
message['To'] = ";".join(user_list)#要发送给谁(多个收件人)
server = smtplib.SMTP()#创建一个SMTP服务
server.connect(email_host)#连接服务器
server.login(send_user,password)#登录服务器
server.sendmail(user,user_list,message.as_string())
server.close()
def send_main(self,pass_list,fail_list):
pass_num = float(len(pass_list))#转化成浮点数
fail_num = float(len(fail_list))
count_num = pass_num+fail_num
pass_result = "%.2f%%" %(pass_num/count_num*100)#%.2f取小数点后两位，再乘以百分之百
fail_result = "%.2f%%" %(fail_num / count_num * 100)
user_list = ['3110000116@qq.com0']
sub = "接口自动化测试报告"
content = "此次一共运行接口个数为%s个，通过个数为%s个，失败个数为%s个，通过率为%s，失败率为%s" %(count_num,pass_num,fail_num,pass_result,fail_result)
self.send_mail(user_list,sub,content)
主程序入口
import sys
sys.path.append("D:/PycharmProjects/Interface")
from base.run_method import RunMethod
from data.get_data import GetData
from util.common_util import CommonUtil
from data.dependent_data import DependentData
from util.send_email import SendEmail
from util.open_header import OpenHeader
from util.Open_Json import Open_Json
class RunTest:
def __init__(self):
self.run_method = RunMethod()
# 实例化RunMethod类，构造run_method对象，通过对象调用RunMethod里面的方法和属性
self.data = GetData()
# 实例化GetData这个类，构造data对象，通过对象调用GetData类里面的方法和属性
self.com_util = CommonUtil()
self.send_mai = SendEmail()
#程序执行的主入口
def go_on_run(self):
res = None
pass_count = []
fail_count = []
#拿到行数
rows_count = self.data.get_case_linse()
#print(rows_count)
#第一行一般是标题，把第一行拿出来，然后再轮询
for i in range(1,rows_count):
is_run = self.data.get_is_run(i)
if is_run:
url = self.data.get_url(i)
method = self.data.get_request_method(i)
request_data = self.data.get_data_for_json(i)#excel里面的是请求数据名，内容需要到json里调用
header = self.data.is_header(i)
expect = self.data.get_expcet_data(i)#获取的预期结果在表格内
#expect = self.data.get_expcet_data_for_mysql(i)#获取的预期结果在数据库
depend_case = self.data.is_depend(i)
if depend_case != None:
self.depend_data = DependentData(depend_case)
#获取依赖的响应数据
depend_response_data = self.depend_data.get_data_for_key(i)
#获取依赖的key
depend_key = self.data.get_deoend_field(i)
request_data[depend_key] = depend_response_data
if header == 'write':
res = self.run_method.run_main(method,url,request_data)
op_header = OpenHeader(res)
op_header.write_cookie()
elif header == 'yes':
op_json = Open_Json('../dataconfig/cookie.json')
cookie = op_json.get_data("apsid")
header = {
"apsid":cookie
}
res = self.run_method.run_main(method, url, request_data, header)
else:
res = self.run_method.run_main(method,url,request_data)
#if self.com_util.is_equal_dict(expect, res) == 0:
if self.com_util.is_contain(expect,res):
self.data.write_result(i,'pass')
pass_count.append(i)
else:
self.data.write_result(i,res)
fail_count.append(i)
self.send_mai.send_main(pass_count,fail_count)
print("成功的用例数：",len(pass_count))
print("失败的用例数：",len(fail_count))
if __name__ == '__main__':
run = RunTest()
run.go_on_run()
2623
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
