class LoginTest(RunTest):
"""登录模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "ByPassword"))
def test_ByPassword(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
res = self.start(self.isSkip_num, self.apiName_num, url,
self.method_num, self.headers_num, self.para_num,
self.data_num, self.desc_num, self.relateData_num,
self.expect_num, value)
try:
self.assertEqual(True, checkOut(res, self.expect))
self.logger.info("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(robot_url,
mobile,
content=f"测试失败！！！接口返回为：{res}, 接口预期结果为：{self.expect}")
raise err
class LoginTest(RunTest):
"""登录商户系统"""
# 获取当前文件路径god
project = os.path.dirname(__file__)[-4:]
# 读取xls中god列
a = ReadData(project, project)
# 通过类名获取模块名
fieldname = sys._getframe().f_code.co_name[:-4]
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') % (self.fieldname, count))
def tearDown(self):
self.logger.debug("...end %s case %s...".center(80, '#') % (self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "LoginByPass"))
def test_LoginByPass(self, value):
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
res = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num, self.para_num,
self.data_num, self.desc_num, self.relateData_num, self.expect_num, value, verify=False)
print(res)
try:
self.assertEqual(True, checkOut(self.res, self.expect))
sss["cookies"] = requests.utils.dict_from_cookiejar(res.cookies)
self.logger.info("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(robot_url, mobile, content=f"登录异常，接口返回为：{self.res}, 接口预期结果为：{self.expect}")
raise err
class LoginTest(unittest.TestCase):
"""地图找店模块"""
# 通过文件名获取project参数的值
project = os.path.dirname(__file__)[-4:]
a = ReadData(project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
@ddt.data(*a.get_data_by_api(fieldname, "ByPassword"))
def test_ByPassword(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env_num = self.a.get_num_name("环境")
body_num = self.a.get_num_name("请求体")
expect_num = self.a.get_num_name("预期结果")
env = value[env_num]
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
result = requests.post(url=url, json=eval(value[body_num]))
res = result.json()
# print(res["code"])
self.assertEqual(res["code"], eval(value[expect_num])["code"])
class commissionTest(RunTest):
"""佣金模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "aCommissionStatistic"))
def test_aCommissionStatistic(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
sss["cookies"] = ";".join(
['{}={}'.format(*_) for _ in sss["cookie"].items()])
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "bcommissionorg"))
def test_bcommissionorg(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "cCommissionList"))
def test_cCommissionList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "dCommissionFactoringInfo"))
def test_dCommissionFactoringInfo(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "exfProtocolList"))
def test_exfProtocolList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "fxfProtocolInfo"))
def test_fxfProtocolInfo(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "gReferralList"))
def test_gReferralList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "hGuideList"))
def test_hGuideList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "iOrderList"))
def test_iOrderList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "kOperator"))
def test_kOperator(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "lProjectList"))
def test_lProjectList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "mApplyProtocolUrl"))
def test_mApplyProtocolUrl(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "nSettlementList"))
def test_nSettlementList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "oBankAcountList"))
def test_oBankAcountList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "paddFastSettlement"))
def test_paddFastSettlement(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "qFactoringCancel"))
def test_qFactoringCancel(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
sss["hash_commissionApplyId"] = '{"commissionApplyType":2,"commissionApplyId":"' + sss[
"hash_commissionApplyId"] + '"}'
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
class Rent_detailTest(RunTest):
"""租房详情页"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-9:]
# print(project)
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
cls.cookie_txt = rent_saas_login(sss["env"])
sss["roomNo"] = int(time.time())
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "create_new_rent_house")) #接口对应的名称
def test_01_create_new_rent_house(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[8:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookie_txt)
sss["ID4"] = str(sss["ID4"])
sss["restful_rentID"] = json.dumps({"rentId": sss["ID4"]})
@ddt.data(*a.get_data_by_api(fieldname,
"update_rent_base_info")) # 接口对应的名称
def test_02_update_rent_base_info(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[8:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookie_txt)
@ddt.data(*a.get_data_by_api(fieldname, "update_RentStatus")) # 接口对应的名称
def test_03_update_RentStatus(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[8:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookie_txt)
@ddt.data(*a.get_data_by_api(fieldname, "add_rent_follow_up")) # 接口对应的名称
def test_04_add_rent_follow_up(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[8:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookie_txt)
class DeveloperTest(RunTest):
"""开发商列表"""
# 获取当前文件路径god
project = os.path.dirname(__file__)[-3:]
# 读取xls中god列
a = ReadData(project, "god")
# 通过类名获取模块名
fieldname = sys._getframe().f_code.co_name[:-4]
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
print(sss["env"])
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "DeveloperList"))
def test_DeveloperList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "DeveloperSearch"))
def test_DeveloperSearch(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "DeveloperEidt"))
def test_DeveloperEidt(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
class OrderTest(RunTest):
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
cls.result = None
cls.desc = None
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(
robot_url,
mobile,
content=
f"{self.desc}测试失败！接口返回为：{self.res}, 接口预期结果为：{self.expect}")
raise err
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "aOrder"))
def test_aOrder(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
#print("签名",str_sign_list)
value.append(str_sign_list)
print("签名", value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "aPurOrder"))
def test_aPurOrder(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
#print("签名",str_sign_list)
value.append(str_sign_list)
print("签名", value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
time.sleep(3)
@ddt.data(*a.get_data_by_api(fieldname, "bOrderdetail"))
def test_bOrderdetail(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "cOrderList"))
def test_cOrderList(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "dBookingList"))
def test_dBookingList(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "eBookingToOrder"))
def test_eBookingToOrder(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "fChange"))
def test_fChange(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
receivableAmount = random.randint(10, 1000)
sss["receivableAmount"] = receivableAmount
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "gChecklist"))
def test_gChecklist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "hperformancechange"))
def test_hperformancechange(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "iperformancelist"))
def test_iperformancelist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "jperformencedetail"))
def test_jperformencedetail(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "kamountchange"))
def test_kamountchange(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
contractAmount = random.randint(50000, 100000)
sss["contractAmount"] = contractAmount
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "lamountchangelist"))
def test_lamountchangelist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "mdatechange"))
def test_mdatechange(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "ndatachangelist"))
def test_ndatachangelist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "ordercancel"))
def test_ordercancel(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "pcancellist"))
def test_pcancellist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "qchangephone"))
def test_qchangephone(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
print(str_sign_list)
value.append(str_sign_list)
print("qianming", value)
sss["version"] = sss["versionName"][1:]
customerMobile = random.randint(18000000000, 18900000000)
sss["customerMobile"] = str(customerMobile)
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "rphonechanglist"))
def test_rphonechanglist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "dOrderSign"))
def test_dOrderSign(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
#print(str_sign_list)
value.append(str_sign_list)
#print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "sreceiptmoney"))
def test_sreceiptmoney(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] # 表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri # a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
t = time.time()
paymentDoc = round(t * 1000)
print(paymentDoc)
sss["paymentDoc"] = paymentDoc
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "trefund"))
def test_trefund(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] # 表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri # a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
'''t = time.time()
paymentDoc = round(t * 1000)
print(paymentDoc)
sss["paymentDoc"] = paymentDoc'''
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
class StoreTest(RunTest):
"""门店模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
# @ddt.data(*a.get_data_by_api(fieldname, "StoreList"))
# def test_StoreList(self, value):
# """门店列表"""
# # 通过函数名获取apiName参数的值
# self.apiName = (inspect.stack()[0][3])[5:]
# env = value[self.env_num]
# url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# result = self.start(self.isSkip_num, self.method_num, url, self.para_num, self.data_num, self.api_name,
# self.desc_num, self.relateData_num, value, headers=value[self.headers_num])
# # result = requests.post(url=url, json=value[self.data_num])
# res = result.json()
# self.logger.debug(f"响应结果 :{res}")
# self.logger.debug(f"预期结果 :{value[self.expect_num]}")
# # print(res["code"])
# self.assertEqual(res["code"], value[self.expect_num]["code"])
# data = value[self.data_num]
# if res["data"]["results"]:
# if res["data"]["totalRecord"] >= data[0]["pageSize"]:
# self.assertEqual(len(res["data"]["results"]), data[0]["pageSize"])
# else:
# self.assertEqual(len(res["data"]["results"]), res["data"]["totalRecord"])
# else:
# self.assertEqual(res["data"]["results"], None)
# print(res["data"]["totalRecord"])
@ddt.data(*a.get_data_by_api(fieldname, "StoreList"))
def test_StoreList(self, value):
"""门店列表"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
class WebLoginTest(RunTest):
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
cls.result = None
cls.desc = None
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(
robot_url,
mobile,
content=
f"{self.desc}测试失败！接口返回为：{self.res}, 接口预期结果为：{self.expect}")
raise err
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "WebLogin"))
def test_WebLogin(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
# print("weburl=",url)
sss["referer"] = url[:-18]
sss["webhost"] = self.a.get_domains()[env][8:]
# print("ssssssssssssss",sss)
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
sss["version"] = sss["versionName"][1:]
# 调起请求
num = sss["referer"] + "/ddfs/login"
# print("num = ",num)
sss["Referer"] = num
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
sss["cookies"] = requests.utils.dict_from_cookiejar(
self.result.cookies)
class AgentTest(RunTest):
"""地图找店模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "listAgent"))
def test_listAgent(self, value):
"""经纪人列表"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
sss["cityIds_agent"] = [
"3", "450", "619", "852", "1406", "2179", "9393", "10204"
]
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "getAgentDetailInfo"))
def test_getAgentDetailInfo(self, value):
"""经纪人详情信息"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
sss["agentId"] = 6537143
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "getCityMap"))
def test_getCityMap(self, value):
"""城市列表"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "getClueList"))
def test_getClueList(self, value):
"""指定经纪人线索列表"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
sss["agentId_str"] = str(sss["agentId"])
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"])
@ddt.data(*a.get_data_by_api(fieldname, "getCompany"))
def test_getCompany(self, value):
"""获取指定公司信息"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
sss["companyId"] = 82200912
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"])
@ddt.data(*a.get_data_by_api(fieldname, "getOrgNetCardData"))
def test_getOrgNetCardData(self, value):
"""根据ID获取经纪人网商卡数据"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "listStoreOrCompanyAgent"))
def test_listStoreOrCompanyAgent(self, value):
"""根据经纪人获得门店店长信息"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
sss["storeId"] = 82351552
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
class ddmfTest(RunTest):
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
cls.result = None
cls.desc = None
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(
robot_url,
mobile,
content=
f"{self.desc}测试失败！接口返回为：{self.res}, 接口预期结果为：{self.expect}")
raise err
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "aaloginddmf"))
def test_aaloginddmf(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddmf"][env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
sss["cookies1"] = requests.utils.dict_from_cookiejar(
self.result.cookies)
sss['userIdd'] = str(sss['userIdd'])
print(sss)
@ddt.data(*a.get_data_by_api(fieldname, "nSettlementList"))
def test_nSettlementList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddmf"][env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
dict_cookie = sss["cookies1"]
sss["cookies2"] = ";".join(
['{}={}'.format(*_) for _ in dict_cookie.items()])
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
#请求响应的data返回结果
data_list = sss["dataresult"]
print(data_list)
data_dict = {}
key = sss["orderNumber"]
value = sss["commissionId"]
for i in range(0, len(key)):
data_dict[key[i]] = value[i]
print("返回的列表为", data_dict)
orderId = sss["orderId"]
print(orderId)
sss["commissionIdreal"] = data_dict[str(orderId)]
print(sss["commissionIdreal"])
#请求响应的orderId，全部提取出来，放到一个列表里
# order_list = sss["orderNumber"]
# print(order_list)
# #遍历要请佣的orderId在order_list的位置，并且将下标返回
# orderIdtest = str(sss["orderId"])
# print(orderIdtest)
# print (len(order_list))
# for i in range(1,len(order_list)):
# if order_list[i] == orderIdtest:
# #在dataresult这个列表里，把这个下表元素提取出来,这个元素是一个字
# sss["index"] = i
# #然后再把这个字典中的factoringCommissionId取出来，作为请佣时传入的factoringCommissionId
# else:
# print ("列表里没有这个order")
# print (sss["index"])
# index = sss["index"]
# data_dict = data_list[index]
# #sss["factoringCommissionId"] = data_dict["factoringCommissionId"]
@ddt.data(*a.get_data_by_api(fieldname, "oBankAcountList"))
def test_oBankAcountList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddmf"][env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "paddFastSettlement"))
def test_paddFastSettlement(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddmf"][env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "pbgetthebussinessId"))
def test_pbgetthebussinessId(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddmf"][env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "qupload"))
def test_qupload(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddmf"][env] + uri
sss["invoiceCode"] = random.randint(12345678, 87654321)
sss["invoiceNo"] = random.randint(12345678, 98765432)
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
time.sleep(5)
class TradeTest(RunTest):
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
cls.result = None
cls.desc = None
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') % (self.fieldname, count))
def tearDown(self):
if self.result:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(robot_url, mobile, content=f"{self.desc}测试失败！接口返回为：{self.res}, 接口预期结果为：{self.expect}")
raise err
self.logger.debug("...end %s case %s...".center(80, '#') % (self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "aaposliest"))
def test_aaposliest(self, value):
#关联pos单
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
#获取当前时间戳
ts = time.time()
paymenttime = round(ts*1000)
sss["paymentTime"] = paymenttime
#获取凭证号,考虑用时间戳来弄
#paymentId = random.randint(384728348,9284348594399)
sss["paymentDoc"] = paymenttime
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num,
self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "abcheck"))
def test_abcheck(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num,
self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "abdchange"))
def test_abdchange(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num,
self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "abedetail"))
def test_abedetail(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num,
self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "accoutlist1"))
def test_accoutlist1(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "accoutlist2"))
def test_accoutlist2(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "breceivable"))
def test_breceivable(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "creceivablelist"))
def test_creceivablelist(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "dreceivablestatus"))
def test_dreceivablestatus(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "eaddconfirm"))
def test_eaddconfirm(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "fconfirmlist"))
def test_fconfirmlist(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "gconfirm"))
def test_gconfirm(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "hticket"))
def test_hticket(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "iticketlist1"))
def test_iticketlist1(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "iticketlist2"))
def test_iticketlist2(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname,"jticketdetail"))
def test_jticketdetail(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "kvioce"))
def test_kvioce(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "lvioceconfirm"))
def test_lvioceconfirm(self, value):
self.desc = value[self.desc_num]
#开票确认
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "money"))
def test_money(self, value):
self.desc = value[self.desc_num]
#回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "nmoneyconfirmlist"))
def test_nmoneyconfirmlist(self, value):
self.desc = value[self.desc_num]
#回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "nmoneyconfirm"))
def test_nmoneyconfirm(self, value):
self.desc = value[self.desc_num]
#回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "oticketcheck"))
def test_oticketcheck(self, value):
self.desc = value[self.desc_num]
#回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "paxpensereferal"))
def test_paxpensereferal(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "pexpensereferal"))
def test_pexpensereferal(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
# result1 = self.result.text
# print("result1=",result1)
# result2 = json.dumps(result1)
# result2[]
# self.assertAlmostEqual("")
@ddt.data(*a.get_data_by_api(fieldname, "qexpendlist"))
def test_qexpendlist(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "rexpenddetail"))
def test_rexpenddetail(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "sexpendcheck"))
def test_sexpendcheck(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "texpendpayment"))
def test_texpendpayment(self, value):
self.desc = value[self.desc_num]
# 费用申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "uexpendpaylist"))
def test_uexpendpaylist(self, value):
self.desc = value[self.desc_num]
# 费用申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "vexpendpaydetail"))
def test_vexpendpaydetail(self, value):
self.desc = value[self.desc_num]
# 费用申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "wexpendpaycheck"))
def test_wexpendpaycheck(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "xabuget"))
def test_xabuget(self, value):
self.desc = value[self.desc_num]
# 超预算申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "ybugetlist"))
def test_ybugetlist(self, value):
self.desc = value[self.desc_num]
# 超预算申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "ycbugetdetdail"))
def test_ycbugetdetdail(self, value):
self.desc = value[self.desc_num]
# 超预算申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "ydbugetdetcheck"))
def test_ydbugetdetcheck(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "zaddbusiness"))
def test_zaddbusiness(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "zbaddbuscontract"))
def test_zbaddbuscontract(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "zdaddbudgetplan"))
def test_zdaddbudgetplan(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "zebugetplancheck"))
def test_zebugetplancheck(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "zfdelbusiness"))
def test_zfdelbusiness(self, value):
self.desc = value[self.desc_num]
# 回款申请
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
time.sleep(5)
@ddt.data(*a.get_data_by_api(fieldname, "yereceiptconfirm"))
def test_yereceiptconfirm(self, value):
self.desc = value[self.desc_num]
# 线下收款确认
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "paxpensereferaltest"))
def test_paxpensereferaltest(self, value):
self.desc = value[self.desc_num]
# 线下收款确认
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num,
self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
class NewHouseTest(RunTest):
"""个人中心模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
cls.result = None
sss["date"] = getTime()
sss["monday"] = mondayOfWeek()
sss["monthDay"] = monthDay()
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "queryEstates"))
def test_1_queryEstates(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[7:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
if self.res["data"]["pageInfo"]["total"] > self.res["data"][
"pageInfo"]["pageSize"]:
self.assertEqual(len(self.res["data"]["pageData"]), 20)
else:
self.assertEqual(len(self.res["data"]["pageData"]),
self.res["data"]["pageInfo"]["total"])
@ddt.data(*a.get_data_by_api(fieldname, "getEstateXfData"))
def test_2_getEstateXfData(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[7:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"])
@ddt.data(*a.get_data_by_api(fieldname, "getEstateDetail"))
def test_3_getEstateDetail(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[7:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
sss["restful"] = json.dumps({"estateId": sss["houseId"]})
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"])
@ddt.data(*a.get_data_by_api(fieldname, "deleteRecommendEstate"))
def test_4_deleteRecommendEstate(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[7:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"])
@ddt.data(*a.get_data_by_api(fieldname, "addRecommendEstate"))
def test_5_addRecommendEstate(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[7:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"])
class EstateTest(RunTest):
"""楼盘相关用例"""
# 获取当前文件路径god
project = os.path.dirname(__file__)[-4:]
# 读取xls中god列
a = ReadData(project, "shop")
# 通过类名获取模块名
fieldname = sys._getframe().f_code.co_name[:-4]
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
print(sss["env"])
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "EstateAll"))
def test_EstateAll(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "EstateMy"))
def test_EstateMy(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "Basic"))
def test_Basic(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "BasicEdit"))
def test_BasicEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "Property"))
def test_Property(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "PropertyEdit"))
def test_PropertyEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "Layout"))
def test_Layout(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "LayoutEdit"))
def test_LayoutEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "BuildList"))
def test_BuildList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "BuildEdit"))
def test_BuildEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "HouseHoldList"))
def test_HouseHoldList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "HouseHoldEdit"))
def test_HouseHoldEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "Album"))
def test_Album(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "Amenity"))
def test_Amenity(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "AmenityEdit"))
def test_AmenityEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "Developer"))
def test_Developer(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "DeveloperEdit"))
def test_DeveloperEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "SalesOff"))
def test_SalesOff(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "SalesOffEdit"))
def test_SalesOffEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "NewsList"))
def test_NewsList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
class HomeTest(RunTest):
"""项目经理微信网店相关用例"""
# 获取当前文件路径
project = os.path.dirname(__file__)[-11:]
# 读取xls中对应的列
a = ReadData(project, "miniprogram")
# 通过类名获取模块名
fieldname = sys._getframe().f_code.co_name[:-4]
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
print(sss["env"])
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "StoreHome"))
def test_StoreHome(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
res = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "VisitCount"))
def test_VisitCount(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
res = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "NewsList"))
def test_NewsList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
res = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "CouponList"))
def test_CouponList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
res = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ProjectList"))
def test_ProjectList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
res = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "Website"))
def test_Website(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
res = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
class GetVersionTest(RunTest):
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "version"))
def test_version(self, value):
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = "https://shopapi.fangdd.com" + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
try:
host = self.a.get_domains()[env][8:]
sss["host"] = host
str_sign_list = [
self.timestamp, value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调起请求
res = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.info("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
#::send_ding(robot_url, mobile, content=f"测试失败！！！接口返回为：{err}, 接口预期结果为：{self.expect}")
raise err
class H5Test(RunTest):
"""H5相关用例"""
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
print(sss["env"])
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "StoreRange"))
def test_StoreRange(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "LayoutList"))
def test1_LayoutList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
sss["layoutId"] = self.res['data'][0]['layoutId']
sss["layoutName"] = self.res['data'][0]['layoutName']
sss["sequenceNo"] = self.res['data'][0]['sequenceNo']
@ddt.data(*a.get_data_by_api(fieldname, "LayoutDetail"))
def test2_LayoutDetail(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName) + str(sss["layoutId"])
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "LayoutEdit"))
def test3_LayoutEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "QuantityDtail"))
def test1_QuantityDtail(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "QuantityEdit"))
def test2_QuantityEdit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ClueList"))
def test_ClueList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ClueAdd"))
def test_ClueAdd(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ClueOperationData"))
def test_ClueOperationData(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ClueRealtorDayList"))
def test_ClueRealtorDayList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ClueRealtorWeekList"))
def test_ClueRealtorWeekList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ClueRealtorMonList"))
def test_ClueRealtorMonList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "AddRealtorRecord"))
def test_AddRealtorRecord(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "TotalStatistics"))
def test_TotalStatistics(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "StoreMonList"))
def test_StoreMonList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "StoreWeekList"))
def test_StoreWeekList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "StoreDayList"))
def test_StoreDayList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "StoreDetail"))
def test_StoreDetail(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "StoreDetailData"))
def test_StoreDetailData(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "UserSop"))
def test_UserSop(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "UserWeekSop"))
def test_UserWeekSop(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "UserSopHelp"))
def test_UserSopHelp(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ProjectMonthSop"))
def test_ProjectMonthSop(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "ProjectSopHelp"))
def test_ProjectSopHelp(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "SopProjectInfo"))
def test_SopProjectInfo(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
class Rent_DatalistTest(RunTest):
"""租房数据列表模块"""
# 通过文件夹路径获取project参数的值
project = os.path.dirname(__file__)[-9:]
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
cls.cookie_txt = rent_saas_login(sss["env"])
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "list_Inspect")) #租房实勘列表
def test_01_list_Inspect(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[8:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookie_txt)
@ddt.data(*a.get_data_by_api(fieldname, "list_RentKey")) # 租房钥匙列表
def test_02_list_RentKey(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[8:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookie_txt)
@ddt.data(*a.get_data_by_api(fieldname, "list_RentFllowup")) # 租房跟进列表
def test_03_list_RentFllowup(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[8:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookie_txt)
@ddt.data(*a.get_data_by_api(fieldname, "list_RentGuide")) # 租房带看列表
def test_04_list_RentGuide(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[8:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookie_txt)
class LoginTest(RunTest):
project = os.path.dirname(__file__)[-4:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "login_password"))
def test_login_password(self, value):
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains(
)[env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
sss["versionNo"] = sss["versionNo"][1:]
# 调起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False)
sss["userId_tp"] = str(sss["userId_tp"])
class IncomeTest(RunTest):
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
cls.result = None
cls.desc = None
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(
robot_url,
mobile,
content=
f"{self.desc}接口失败！接口返回为：{self.res}, 接口预期结果为：{self.expect}")
raise err
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "aincomelist"))
def test_aincomelist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddxf"][
env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
# print(sss)
# print(sss["userId"])
# print(sss["token"])
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "bincomelist"))
def test_bincomelist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddxf"][
env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
# print(sss)
# print(sss["userId"])
# print(sss["token"])
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "crejectlist"))
def test_crejectlist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddxf"][
env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
# print(sss)
# print(sss["userId"])
# print(sss["token"])
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "dreturnedlist"))
def test_dreturnedlist(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddxf"][
env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
# print(sss)
# print(sss["userId"])
# print(sss["token"])
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "einvoice"))
def test_einvoice(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddxf"][
env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
# print(sss)
# print(sss["userId"])
# print(sss["token"])
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "fnoticket"))
def test_fnoticket(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddxf"][
env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
# print(sss)
# print(sss["userId"])
# print(sss["token"])
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "gticket"))
def test_gticket(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] #表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddxf"][
env] + uri #a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "hrefund"))
def test_hrefund(self, value):
self.desc = value[self.desc_num]
self.apiName = (inspect.stack()[0][3]
)[5:] # 表示读取列表中的第一个元素（字典元素)的第三个元素？？？？？但是第三个应该是 请求头啊
env = value[self.env_num]
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["ddxf"][
env] + uri # a.get_domains是字典，因为有好几个环境，根据测试环境来获得域名，域名+uri就是访问地址
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]),
str(sss["token"]), self.timestamp, value[self.method_num].upper(),
uri
]
# print(str_sign_list)
value.append(str_sign_list)
# print(value)
sss["version"] = sss["versionName"][1:]
# # # 调起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
class OrgTest(RunTest):
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-7:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
cls.result = None
cls.desc = None
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') % (self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(self.robot_url, self.mobile,
content=f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url, self.mobile, content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') % (self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "userdetail"))
def test_userdetail(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "carriedetail"))
def test_carriedetail(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "eagrrement"))
def test_eagrrement(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "fcitylist"))
def test_fcitylist(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "gcitydetail"))
def test_gcitydetail(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "icityuser"))
def test_icityuser(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "jteamdetail"))
def test_jteamdetail(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "kchangeteamuser"))
def test_kchangeteamuser(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "larealist"))
def test_larealist(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "mareadetail"))
def test_mareadetail(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "oaddcity"))
def test_oaddcity(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "pgivecity"))
def test_pgivecity(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "quserlist"))
def test_quserlist(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num,
self.para_num, self.data_num, self.desc_num, self.relateData_num, self.expect_num,
value, cookies=sss["cookies"], verify=False)
class MapSourceTest(RunTest):
"""地图找店模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "CityDistrict"))
def test_CityDistrict(self, value):
"""城市区域列表"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "CitySection"))
def test_CitySection(self, value):
"""城市区域板块列表"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "StoreInfoList"))
def test_StoreInfoList(self, value):
"""地图门店区域列表"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "StoreByCodition"))
def test_StoreByCodition(self, value):
"""门店列表-地图区域条件"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
class xfcheckTest(RunTest):
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
cls.result = None
cls.desc = None
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(
robot_url,
mobile,
content=
f"{self.desc}测试失败！接口返回为：{self.res}, 接口预期结果为：{self.expect}")
raise err
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "agetcommission"))
def test_agetcommission(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()["commiss"][env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "bcheck"))
def test_bcheck(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()["commiss"][env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
time.sleep(5)
class ReportTest(RunTest):
"""业务订单风控模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
cls.cookies = json.loads(read_cookie.readcookie().replace("\'", '\"'))
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "HouseRepayDetail"))
def test_HouseRepayDetail(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "HouseRepayAnalysis"))
def test_HouseRepayAnalysis(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "CityRepayDetail"))
def test_CityRepayDetail(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "CityRepayAnalysis"))
def test_CityRepayAnalysis(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "RepayList"))
def test_RepayList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "RepayStatistics"))
def test_RepayStatistics(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "RepayWard"))
def test_RepayWard(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "getPenalty"))
def test_getPenalty(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "PenaltyStatistics"))
def test_PenaltyStatistics(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "AmountFunnelReport"))
def test_AmountFunnelReport(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "OrderFunnelReport"))
def test_OrderFunnelReport(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "ReleaseRepayAmount"))
def test_ReleaseRepayAmount(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "CityRankRelease"))
def test_CityRankRelease(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "OverdueRepayAmount"))
def test_OverdueRepayAmount(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "CityRankOverdue"))
def test_CityRankOverdue(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "AgentReport"))
def test_AgentReport(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "NewFactoringAgent"))
def test_NewFactoringAgent(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "ChannelReport"))
def test_ChannelReport(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "MerchantReport"))
def test_MerchantReport(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=self.cookies)
class StoreManageTest(RunTest):
"""门店模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@unittest.SkipTest
@ddt.data(*a.get_data_by_api(fieldname, "ResponsibilityStore"))
def test_ResponsibilityStore(self, value):
"""责任田分类分级"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
sss["cookies_str"] = ";".join(
['{}={}'.format(*_) for _ in sss["cookies"].items()])
sss["cityId_list_str"] = ','.join(
list(map(lambda x: str(x), sss["city_list"])))
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
@ddt.data(*a.get_data_by_api(fieldname, "ResponsibilityStoreList"))
def test_ResponsibilityStoreList(self, value):
"""门店列表筛选"""
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
sss["UserId"] = f'userId={sss["ID"]}'
sss["baishan_id"] = sss["city_list"][0]
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
class LoginTest(RunTest):
"""登录模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-7:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "Login"))
def test_Login(self, value):
if sss["env"] == "prod":
sss["sms_code"] = get_smsCode(
"prod",
'https://jr.fangdd.com/jgj/api/user/smgsend',
'post',
json={
"mobile": "13058019302",
"type": 1
})
elif sss["env"] == "pre":
sss["sms_code"] = get_smsCode(
"pre",
'https://jr.fangdd.com.cn/jgj/api/user/smgsend',
'post',
json={
"mobile": "18652980686",
"type": 1
})
elif sss["env"] == "test":
sss["sms_code"] = get_smsCode(
"test",
'https://jr.fangdd.net/jgj/api/user/smgsend',
'post',
json={
"mobile": "13682521706",
"type": 1
})
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
print("sss等于", sss)
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["syb"][env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
sss["cookies3"] = requests.utils.dict_from_cookiejar(
self.result.cookies)
print(sss)
@ddt.data(*a.get_data_by_api(fieldname, "Mchecklist"))
def test_Mchecklist(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()["syb"][env] + uri
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies3"])
@ddt.data(*a.get_data_by_api(fieldname, "Nfactoring"))
def test_Nfactoring(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()["syb"][env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies3"],
verify=False)
time.sleep(3)
@ddt.data(*a.get_data_by_api(fieldname, "Ngfactoring"))
def test_Ngfactoring(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()["syb"][env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies3"],
verify=False)
time.sleep(10)
@ddt.data(*a.get_data_by_api(fieldname, "Oacheckcommiss"))
def test_Oacheckcommiss(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()["commiss"][env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "Ochangechanel"))
def test_Ochangechanel(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()["syb"][env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies3"],
verify=False)
@ddt.data(*a.get_data_by_api(fieldname, "Odcheckfactoring"))
def test_Odcheckfactoring(self, value):
self.desc = value[self.desc_num]
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()["commiss"][env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
cookies=sss["cookies"],
verify=False)
class LoginTest(RunTest):
"""登录模块"""
# 通过文件夹路径获取project参数的值
project = os.path.dirname(__file__)[-9:]
# print(project)
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "ByPassword")) #接口对应的名称
def test_ByPassword(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
url = self.a.get_domains()[env] + self.a.get_apiPath(
self.fieldname, self.apiName)
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num,
self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num,
self.relateData_num, self.expect_num, value)
sss["ID"] = str(sss["ID"])
sss["ID2"] = str(sss["ID2"])
sss["ID3"] = str(sss["ID3"])
sss["ID5"] = str(sss["ID5"])
class StoreTest(RunTest):
"""业务订单风控模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-4:]
# 读取文件实例化
a = ReadData(project, project)
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
# 获取项目名后，获取机器人相关配置
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
cls.cookies = json.loads(read_cookie.readcookie().replace("\'", '\"'))
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') % (self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
self.logger.error("测试结果 :测试失败！")
send_ding(self.robot_url, self.mobile,
content=f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}",runType=1)
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url, self.mobile, content=f"{self.desc}测试失败！\n测试反馈:{self.result}",runType=1)
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') % (self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "EnterpriseAuditList"))
def test_EnterpriseAuditList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num, self.para_num,
self.data_num, self.desc_num, self.relateData_num, self.expect_num, value, cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "EnterpriseInfo"))
def test_EnterpriseInfo(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num, self.para_num,
self.data_num, self.desc_num, self.relateData_num, self.expect_num, value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "Operator"))
def test_Operator(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num, self.relateData_num, self.expect_num, value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "BankList"))
def test_BankList(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num, self.relateData_num, self.expect_num, value,
cookies=self.cookies)
@ddt.data(*a.get_data_by_api(fieldname, "EnterpriseLog"))
def test_EnterpriseLog(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# 调用接口发起请求
self.result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num,
self.headers_num, self.para_num,
self.data_num, self.desc_num, self.relateData_num, self.expect_num, value,
cookies=self.cookies)
class DynamicTest(RunTest):
"""动态相关用例"""
project = os.path.dirname(__file__)[-7:]
a = ReadData(project, project)
fieldname = sys._getframe().f_code.co_name[:-4]
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') %
(self.fieldname, count))
def tearDown(self):
if self.result and type(self.result) != str:
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.debug("测试结果 :测试通过！")
except Exception as err:
print(sss["env"])
self.logger.error("测试结果 :测试失败！")
send_ding(
self.robot_url,
self.mobile,
content=
f"{self.desc}测试失败！\n接口返回为：{self.res}, 预期结果为：{self.expect}")
raise err
elif self.result and type(self.result) == str:
send_ding(self.robot_url,
self.mobile,
content=f"{self.desc}测试失败！\n测试反馈:{self.result}")
raise Exception
self.logger.debug("...end %s case %s...".center(80, '#') %
(self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "Add"))
def test1_Add(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "List"))
def test2_List(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
sss["id"] = self.res['data']['pageData'][0]['id']
@ddt.data(*a.get_data_by_api(fieldname, "Edit"))
def test3_Edit(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "Zan"))
def test4_Zan(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "Comment"))
def test5_Comment(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "Delete"))
def test6_Delete(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName) + str(
sss["id"]) + "/del"
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "Share"))
def test7_Share(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
res = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "Detail"))
def test8_Detail(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
@ddt.data(*a.get_data_by_api(fieldname, "UserInfo"))
def test9_UserInfo(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[6:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [
str(sss["userId"]), sss["token"], self.timestamp,
value[self.method_num].upper(), uri
]
value.append(str_sign_list)
# 调用接口发起请求
self.result = self.start(self.project,
self.isSkip_num,
self.apiName_num,
url,
self.method_num,
self.headers_num,
self.para_num,
self.data_num,
self.desc_num,
self.relateData_num,
self.expect_num,
value,
verify=False,
timeout=10)
class LoginTest(RunTest):
"""登录模块"""
# 通过文件名夹获取project参数的值
project = os.path.dirname(__file__)[-11:]
# 读取文件实例化
a = ReadData(project, 'miniprogram')
# 通过类名获取fieldname的值
fieldname = sys._getframe().f_code.co_name[:-4]
json_dict = a.json_data[project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
@classmethod
def setUpClass(cls):
cls.env_num = cls.a.get_num_name("环境")
cls.apiName_num = cls.a.get_num_name("接口名称")
cls.method_num = cls.a.get_num_name("请求方法")
cls.headers_num = cls.a.get_num_name("请求头")
cls.para_num = cls.a.get_num_name("请求参数")
cls.desc_num = cls.a.get_num_name("用例描述")
cls.data_num = cls.a.get_num_name("请求体")
cls.expect_num = cls.a.get_num_name("预期结果")
cls.isSkip_num = cls.a.get_num_name("是否跳过该用例")
cls.relateData_num = cls.a.get_num_name("接口关联参数")
t = time.time()
cls.timestamp = str(round(t * 1000))
sss["timestamp"] = cls.timestamp
def setUp(self):
globals()['count'] += 1
self.logger.debug("...start %s case %s...".center(80, '#') % (self.fieldname, count))
def tearDown(self):
self.logger.debug("...end %s case %s...".center(80, '#') % (self.fieldname, count))
@ddt.data(*a.get_data_by_api(fieldname, "ByPassword"))
def test_ByPassword(self, value):
# 通过函数名获取apiName参数的值
self.apiName = (inspect.stack()[0][3])[5:]
# 获取测试环境参数
env = value[self.env_num]
# 通过环境参数获得接口url
uri = self.a.get_apiPath(self.fieldname, self.apiName)
url = self.a.get_domains()[env] + uri
# ***需要加密的数据在此处添加到列表中即可，反之则不用写这一步***
str_sign_list = [self.timestamp, value[self.method_num].upper(), uri]
value.append(str_sign_list)
# 调起请求
result = self.start(self.project, self.isSkip_num, self.apiName_num, url, self.method_num, self.headers_num, self.para_num,
self.data_num, self.desc_num, self.relateData_num, self.expect_num, value, verify=False)
try:
self.assertEqual(True, checkOut(self.res, self.expect))
self.logger.info("测试结果 :测试通过！")
sss["userId"] = str(sss["userId"])
except Exception as err:
self.logger.error("测试结果 :测试失败！")
json_dict = self.a.json_data[self.project]["robot_data"]
robot_url = json_dict["robot_url"]
mobile = json_dict["mobile"]
send_ding(robot_url, mobile, content=f"测试失败！！！接口返回为：{result}, 接口预期结果为：{self.expect}")
raise err
