# import jsonpath
import random
import requests
import json
# import random
# import datetime
import os
import pymysql
a=0
o='*'*501
p='@@'
k=''
num=123
zu=(o,p,k,num)
'''函数目录：
requests----post请求函数
get_response---发送post请求并获取对应的值
getsql---连接数据库并执行查询语句
panduan---判断接口异常执行的是什么用例
apitest---执行接口异常用例'''
def requests1(url,data,header):
postrequest = requests.post(url=url,data=json.dumps(data),headers=header)
response=postrequest.text
assert '成功'in response
print(response)
return response
# 这个是一个获取值的函数，比如登录获取token
def get_response():
path=input("请输入要获取的值的路径如：['data']['token']")
url = input("请输入请求完整的url如：http://sqmallapiuat.onewo.com/manager-api/activity/add/addBaseActivity")
data = json.loads(input("请输入请求的入参如：{'data'：'小明'}"))
header=input("请输入请求的请求头")
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
aa=postrequest.text
return aa[path]
#连接数据库并执行sql，apitest里面调用了该函数
def getsql(sql):
#连接数据库
db=pymysql.connect(host='rm-wz9926drc689m9g2j.mysql.rds.aliyuncs.com',port=3306,user='mall_uat',password='M%d&6DSMy',charset='utf8',db='mall_uat')
#获取输入光标
cursor=db.cursor()
#执行sql
cursor.execute(sql)
#获取查询结果
dd=cursor.fetchall()
#过去结果的第一条数据
get=dd[0][0]
#关闭光标
cursor.close()
#关闭数据库
db.close()
return get
#这是一个用来判断用例的函数，apitest函数里面调用了函数
def panduan(key,data):
#根据变量的值来判断接口测试执行的是哪个用例，并输出对用的键值和用例名称
if data[key] == o:
print(str(key) + "被改变为"+ "超长501个*")
elif data[key] == p:
print(str(key) + "被改变为"+ "非法字符"+str(data[key]))
elif data[key] == k:
print(str(key) + "被改变为"+ "空字符串‘’"+str(data[key]))
elif data[key] == num:
print(str(key) + "被改变为"+"数字"+str(data[key]))
else:
print("抱歉没有取到任何值")
#遍历data中的每一个4层以内的值传入异常值并发送post请求
def apitest (url ,data ,header,type1):
connt=0
if primrykey==1:
numkey=int(input("请告诉我第几个值是唯一参数："))
# 如果参数是字典
if type(data) == dict:
#用一个值去循环遍历这个字典
for key1 in data:
# 如果这个字典所有的值既不是字典也不是列表
while type(data[key1])!=list and type(data[key1])!=dict:
# 初始化字典的值，为还原参数做准备
ll = data[key1]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
connt=connt+1
# 将异常用例列表的值依次传入字典的值当中
data[key1]=api
if type1==2:
# 判断是执行了哪个用例
panduan(key1, data)
rr=getrequests(path, header, data)
# rr = requests.get(url=url, headers=header, params=data)
print(path)
print(header)
print(data)
print(rr)
print(rr)
if '成功' in rr.text:
print(rr.text)
# else:
# print(rr.text)
# print(path + "接口失败")
if type1 == 1:
if primrykey==1:
if (numkey-1)*len(zu)< connt<=numkey*len(zu):
data[key1]=ll+str(random.randint(1,10000000))
print(data)
if numkey>len(data):
print("唯一参数输入错误")
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 打印响应的内容
print(postrequest.text)
if type1 != 1 and type1 != 2:
print("请求类型输入错误")
# 参数还原
data[key1]=ll
# 退出这个循环，让他继续跑下一个参数
break
#如果这个字典的值是一个列表
while type(data[key1])==list:
#让一个值去遍历这个列表
for f in range(len(data[key1])):
# 如果这个列表的值是一个字典
if type(data[key1][f])==dict:
#让一个值去遍历这个字典
for g in data[key1][f]:
# 将路径赋予一个变量，变量路径太长了不好看所以为了缩短
h=data[key1][f]
#如果这个字典的值既不是字典也不是列表
if type(h[g])!=dict and type(h[g])!=list:
# 初始化字典的值，为还原参数做准备
ll = h[g]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
# 将异常用例列表的值依次传入字典的值当中
h[g] = api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(g,h)
# 参数还原
h[g]=ll
# 打印响应的内容
print(postrequest.text)
# 如果这是一个字典
if type(h[g])==dict:
# 让一个值去遍历这个字典
for i in h[g]:
# 初始化字典的值，为还原参数做准备
ll=h[g][i]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i]=ll
# 打印响应的内容
print(postrequest.text)
# 如果这是一个列表
if type(h[g])==list:
# 让一个值去遍历这个列表
for i in range(len(h[g])):
# 初始化字典的值，为还原参数做准备
ll=h[g][i]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i]=ll
# 打印响应的内容
print(postrequest.text)
#如果这是一个列表
if type(data[key1][f])==list:
# 让一个值去遍历这个列表
for g in range(len(data[key1][f])):
# 将路径赋予一个变量，变量路径太长了不好看所以为了缩短
h=data[key1][f]
if type(h[g])!=dict and type(h[g])!=list:
# 初始化字典的值，为还原参数做准备
ll=h[g]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
h[g]= api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(g, h)
# 参数还原
h[g]=ll
# 打印响应的内容
print(postrequest.text)
#如果这是一个字典
if type(h[g])==dict:
# 让一个值去遍历这个字典
for i in h[g]:
# 初始化字典的值，为还原参数做准备
ll = h[g][i]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
# 让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i]=ll
# 打印响应的内容
print(postrequest.text)
# 如果这是一个列表
if type(h[g])==list:
# 让一个值去遍历这个列表
for i in range(len(h[g])):
# 初始化字典的值，为还原参数做准备
ll = h[g][i]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 如果这既不是列表也不是字典
if type(data[key1][f])!=list and type(data[key1][f])!=dict:
# 初始化字典的值，为还原参数做准备
ll=data[key1][f]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
data[key1][f]= api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(f, data[key1])
# 参数还原
data[key1][f]=ll
# 打印响应的内容
print(postrequest.text)
#退出这个循环跑下一个值
break
#如果这是一个字典
while type(data[key1])==dict:
# 让一个值去遍历这个字典
for f in data[key1]:
#如果值也是一个字典
if type(data[key1][f]) == dict:
# 让一个值去遍历这个字典
for g in data[key1][f]:
# 将路径赋予一个变量，变量路径太长了不好看所以为了缩短
h = data[key1][f]
# 如果值既不是字典也不是列表
if type(h[g]) != dict and type(h[g]) != list:
# 初始化字典的值，为还原参数做准备
ll=h[g]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
h[g] = api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(g, h)
# 参数还原
h[g]=ll
# 打印响应的内容
print(postrequest.text)
# 如果值也是一个字典
if type(h[g]) == dict:
# 让一个值去遍历这个字典
for i in h[g]:
# 初始化字典的值，为还原参数做准备
ll = h[g][i]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i]=ll
# 打印响应的内容
print(postrequest.text)
# 如果值也是一个列表
if type(h[g]) == list:
# 让一个值去遍历这个列表
for i in range(len(h[g])):
# 初始化字典的值，为还原参数做准备
ll = h[g][i]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 如果值也是一个列表
if type(data[key1][f]) == list:
# 让一个值去遍历这个列表
for m in range(len(data[key1][f])):
# 将路径赋予一个变量，变量路径太长了不好看所以为了缩短
h = data[key1][f]
# 如果这个值既不是字典也不是列表
if type(h[m]) != dict and type(h[m]) != list:
# 初始化字典的值，为还原参数做准备
ll = h[m]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
#让传参遍历一遍异常用例
h[m]=api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(m, h)
# 参数还原
h[m] = ll
# 打印响应的内容
print(postrequest.text)
# 如果值也是一个字典
if type(h[m]) == dict:
# 让一个值去遍历这个字典
for i in h[m]:
# 初始化字典的值，为还原参数做准备
ll = h[m][i]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
# 让传参遍历一遍异常用例
h[m][i]=api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(i, h[m])
# 参数还原
h[m] = ll
# 打印响应的内容
print(postrequest.text)
# 如果值也是一个列表
if type(h[m]) == list:
# 让一个值去遍历这个列表
for i in range(len(h[m])):
# 初始化字典的值，为还原参数做准备
ll = h[m][i]
# 让一个值去循环遍历接口测试用例zu，
for api in zu:
# 让传参遍历一遍异常用例
h[m][i]=api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(i, h[m])
# 参数还原
h[m] = ll
# 打印响应的内容
print(postrequest.text)
# 如果值既不是字典也不是列表
if type(data[key1][f])!=list and type(data[key1][f]) !=dict:
# 初始化字典的值，为还原参数做准备
ll = data[key1][f]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
data[key1][f]=api
# 发送post请求
postrequest = requests.post(url=url, data=json.dumps(data), headers=header)
# 判断是执行了哪个用例
panduan(f, data[key1])
# 参数还原
data[key1][f]=ll
# 打印响应的内容
print(postrequest.text)
# 退出这个循环跑下一个值
break
#如果参数是列表
if type(data)==list:
# 让一个值去遍历这个列表
for key1 in range(len(data)):
# 如果值既不是字典也不是列表
while type(data[key1]) != list and type(data[key1]) != dict:
# 初始化字典的值，为还原参数做准备
ll=data[key1]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
data[key1]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(key1, data)
# 参数还原
data[key1]=ll
# 打印响应的内容
print(postrequest.text)
# 退出这个循环跑下一个值
break
# 如果值是列表
while type(data[key1]) == list:
# 让一个值去遍历这个列表
for f in range(len(data[key1])):
# 如果值也是一个字典
if type(data[key1][f]) == dict:
# 让一个值去遍历这个字典
for g in data[key1][f]:
# 缩短路径，方便观看
h = data[key1][f]
# 如果值既不是字典也不是列表
if type(h[g]) != dict and type(h[g]) != list:
# 初始化字典的值，为还原参数做准备
ll=h[g]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g] = api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(g, h)
# 参数还原
h[g]=ll
# 打印响应的内容
print(postrequest.text)
# 如果值是字典
if type(h[g]) == dict:
# 让一个值去遍历这个字典
for i in h[g]:
# 初始化字典的值，为还原参数做准备
ll=h[g][i]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i]=ll
# 打印响应的内容
print(postrequest.text)
# 如果值是列表
if type(h[g]) == list:
# 让一个值去遍历这个列表
for i in range(len(h[g])):
# 初始化字典的值，为还原参数做准备
ll=h[g][i]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 如果值是列表
if type(data[key1][f]) == list:
# 让一个值去遍历这个列表
for g in range(len(data[key1][f])):
# 缩短路径
h = data[key1][f]
# 如果值既不是字典又不是列表
if type(h[g]) != dict and type(h[g]) != list:
# 初始化字典的值，为还原参数做准备
ll=h[g]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(g, h)
# 参数还原
h[g] = ll
# 打印响应的内容
print(postrequest.text)
# 如果值是字典
if type(h[g]) == dict:
# 让一个值去遍历这个字典
for i in h[g]:
# 初始化字典的值，为还原参数做准备
ll=h[g][i]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 如果值是列表
if type(h[g]) == list:
# 让一个值去遍历这个列表
for i in range(len(h[g])):
# 初始化字典的值，为还原参数做准备
ll = h[g][i]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g][i] = api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 如果这个值既不是字典也不是列表
if type(data[key1][f]) != dict and type(data[key1][f]) != list:
# 初始化字典的值，为还原参数做准备
ll=data[key1][f]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
data[key1][f]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(f, data[key1])
# 参数还原
data[key1][f] = ll
# 打印响应的内容
print(postrequest.text)
# 退出这个循环跑下一个值
break
# 如果值是字典
while type(data[key1]) == dict:
# 让一个值去遍历这个字典
for f in data[key1]:
# 如果值是字典
if type(data[key1][f]) == dict:
# 让一个值去遍历这个字典
for g in data[key1][f]:
# 缩短路径
h = data[key1][f]
# 如果这个值既不是字典又不是列表
if type(h[g]) != dict and type(h[g]) != list:
# 初始化字典的值，为还原参数做准备
ll=h[g]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(g, h)
# 参数还原
h[g]= ll
# 打印响应的内容
print(postrequest.text)
# 如果值是字典
if type(h[g]) == dict:
# 让一个值去遍历这个字典
for i in h[g]:
# 初始化字典的值，为还原参数做准备
ll=h[g][i]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g][i]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 让一个值去遍历这个列表
if type(h[g]) == list:
# 让一个值去遍历这个列表
for i in range(len(h[g])):
# 初始化字典的值，为还原参数做准备
ll = h[g][i]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g][i]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 让一个值去遍历这个列表
if type(data[key1][f]) == list:
# 让一个值去遍历这个列表
for g in range(len(data[key1][f])):
# 缩短路径
h = data[key1][f]
# 如果值既不是字典也不是列表
if type(h[g]) != dict and type(h[g]) != list:
# 初始化字典的值，为还原参数做准备
ll=h[g]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(g, h)
# 参数还原
h[g] = ll
# 打印响应的内容
print(postrequest.text)
# 让一个值去遍历这个字典
if type(h[g]) == dict:
# 让一个值去遍历这个列表
for i in h[g]:
# 初始化字典的值，为还原参数做准备
ll=h[g][i]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g][i]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 让一个值去遍历这个列表
if type(h[g]) == list:
# 让一个值去遍历这个列表
for i in range(len(h[g])):
# 初始化字典的值，为还原参数做准备
ll=h[g][i]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
h[g][i]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(i, h[g])
# 参数还原
h[g][i] = ll
# 打印响应的内容
print(postrequest.text)
# 如果值既不是列表也不是字典
if type(data[key1][f]) != list and type(data[key1][f]) != dict:
# 初始化字典的值，为还原参数做准备
ll=data[key1][f]
# 让一个值去循环遍历接口测试用例zu
for api in zu:
# 让传参遍历一遍异常用例
data[key1][f]=api
# 发送post请求
postrequest=requests.post(url=url,data=json.dumps(data),headers=header)
# 判断是执行了哪个用例
panduan(f, data[key1])
# 参数还原
data[key1][f]= ll
# 打印响应的内容
print(postrequest.text)
# 退出这个循环跑下一个值
break
def getrequests(path,header,par):
url = field + path
response=requests.get(url=url, headers=header,params=par)
if '成功' in response.text:
print(response.text)
else:
print(path+"接口失败")
rr=response.text
return rr
#参数中如果有唯一且非空字段则需将代码做优化
# ---------------- 商户端登录到选择门店并传token-------------------------
data={"type":2,
"wxToken":"c2600a85370745dba9e68fd7261f6567",
"phone":"13268873792",
"smsVerCode":"666666"}
field="http://sqmallapiuat.onewo.com/mch-api"# 开发环境
# field="http://sqmallapiuat.onewo.com/manager-api" # 测环境
header={"content-type":"application/json"}
#运营端登陆
path="/login/login"
#登陆url
url=field+path
#发送登陆请求
rr=requests1(url,data,header)
#把token传入header
header["token"]=json.loads(rr)["data"]["token"]
par={"pageSize":5,"pageNum":1}
path='/myData/chooseStoreNew'
rr=getrequests(path,header,par)
getsql("select associate_id from t_store_account_associate a inner join t_store_info b on a.store_id=b.store_id where store_name='419独属王铃7';")
get=getsql("select associate_id from t_store_account_associate a inner join t_store_info b on a.store_id=b.store_id where store_name='419独属王铃7';")
par={"associateId":get}
path="/myData/selected"
rr=getrequests(path,header,par)
header["token"]=json.loads(rr)["data"]
# # ------开始测试---------------
# #创建活动路径
# path="/orderInfo/queryCouponOrderList"
#
# #创建活动url
# url=field+path
# data={
# "couponId": "CI202108091058171118",
# "orderStatus": 0,
# "pageNum": 1,
# "pageSize": 10
# }
# type1=int(input("请输入请求的类型：1，post 2，get ："))
# primrykey=int(input("是否有唯一不能重复的参数：1，有 2，没有 ："))
# apitest(url,data,header,type1)
