def get_data(self, case_num, case_name):
"""
根据用例数据库名找到yaml中对应的连接信息
:param num: 用例序号0,1,2...
:return: [ip, 账号, 密码]
"""
with open(config_path, 'rb') as f:
cont = f.read()
cf = load(cont)
database = operate_excel.get_palce(case_num, case_name)['database']
db = operate_excel.get_palce(case_num, case_name)['db']
data = cf.get(db)[database]
return data
def testCase2(self, id=1):
"""提交订单成功未支付"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'], key=data_test['key'], param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'], data_test['way']))
apijson1 =json.loads(apijson)
global actual
actual = apijson1["data"]["orderNumber"]
sql = operate_excel.get_palce(case_num=id, case_name=MyTest.name)['sql'].format(actual)
actual_two = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).Perform()
try:
self.assertIsNotNone(actual, msg='实际值不存在')
Log().info('对【订单号】断言,生成订单号%s' % (actual))
except:
Log().warning('对【订单号】断言，订单号生成失败')
raise
finally:
try:
self.assertEqual(int(expect_two['tradestatus']), actual_two, msg='预期和返回不一致')
Log().info('对【订单状态】断言,断言结果--预期值%s == 实际值%s' % (expect_two['tradestatus'], actual_two))
except:
Log().warning('对【订单状态】断言,断言结果--预期值%s != 实际值%s' % (expect_two['tradestatus'], actual_two))
raise
def testCase1(self, id=35):
"""新增地址"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'], key=data_test['key'], param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'], data_test['way']))
apijson2 = json.loads(apijson)
actual_one = apijson2["isSuccess"]
global address_id1
address_id1 = apijson2["data"]
actual_two = address_id1
sql = operate_excel.get_palce(case_num=id, case_name=MyTest.name)['sql']
expect_two = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).Perform()
try:
self.assertEqual(int(expect_one['isSuccess']), actual_one, msg='预期和返回不一致')
Log().info('对【isSuccess】断言,断言结果--预期值%s == 实际值%s' % (expect_one['isSuccess'], actual_one))
except:
Log().warning('对【isSuccess】断言,断言结果--预期值%s != 实际值%s' % (expect_one['isSuccess'], actual_one))
raise
finally:
try:
self.assertEqual(expect_two, actual_two, msg='预期和返回不一致')
Log().info('对【地址id】断言,断言结果--预期值%s == 实际值%s' % (expect_two, actual_two))
except:
Log().warning('对【地址id】断言,断言结果--预期值%s != 实际值%s' % (expect_two, actual_two))
raise
def testCase02(self, id=24):
"""获取个人发布内容"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
sql = operate_excel.get_palce(case_num=id)['sql']
expect_two = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).Perform()
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'], key=data_test['key'], param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'], data_test['way']))
apijson1 = json.loads(apijson)
actual_one = apijson1["data"][0]["noteBaseInfo"]["content"]
actual_two = apijson1["data"][0]["noteBaseInfo"]["noteId"]
global note_id
note_id = actual_two
try:
self.assertEqual(expect_one['content'], actual_one, msg='预期和返回不一致')
Log().info('对【发布内容】断言,断言结果--预期值%s == 实际值%s' % (expect_one['content'], actual_one))
except:
Log().warning('对【发布内容】断言,断言结果--预期值%s != 实际值%s' % (expect_one['content'], actual_one))
raise
finally:
try:
self.assertEqual(expect_two, actual_two, msg='预期和返回不一致')
Log().info('对【发布内容id】断言,断言结果--预期值%s == 实际值%s' % (expect_two, actual_two))
except:
Log().warning('对【发布内容id】断言,断言结果--预期值%s != 实际值%s' % (expect_two, actual_two))
raise
def testCase5(self, id=39):
"""删除地址"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'], key=data_test['key'], param=data_test['param'].replace("{0}", str(address_id2)),
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'], data_test['way']))
apijson1 = json.loads(apijson)
actual_one = apijson1["isSuccess"]
sleep(1)
sql = operate_excel.get_palce(case_num=id)['sql'].format(address_id2)
actual_two = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).Perform()
try:
self.assertEqual(int(expect_one['isSuccess']), actual_one, msg='预期和返回不一致')
Log().info('对【isSuccess】断言,断言结果--预期值%s == 实际值%s' % (expect_one['isSuccess'], actual_one))
except:
Log().warning('对【isSuccess】断言,断言结果--预期值%s != 实际值%s' % (expect_one['isSuccess'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two['COUNT(*)']), actual_two, msg='预期和返回不一致')
Log().info('对【删除结果数】断言,断言结果--预期值%s == 实际值%s' % (expect_two['COUNT(*)'], actual_two))
except:
Log().warning('对【删除结果数】断言,断言结果--预期值%s != 实际值%s' % (expect_two['COUNT(*)'], actual_two))
raise
def testCase12(self, id=34):
"""删除发布内容"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'].format(note_id), key=data_test['key'], param=data_test['param'].format(note_id),
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'], data_test['way']))
apijson2 = json.loads(apijson)
actual_one = apijson2["msg"]
sql = operate_excel.get_palce(case_num=id, case_name=MyTest.name)['sql'].format(note_id)
actual_two = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).Perform()
try:
self.assertEqual(expect_one['msg'], actual_one, msg='预期和返回不一致')
Log().info('删除成功，对【删除结果】断言,断言结果--预期值%s == 实际值%s' % (expect_one['msg'], actual_one))
except:
Log().warning('删除失败，对【删除结果】断言,断言结果--预期值%s != 实际值%s' % (expect_one['msg'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two['COUNT(*)']), actual_two, msg='预期和返回不一致')
Log().info('对【删除数】断言,断言结果--预期值%s == 实际值%s' % (expect_two['COUNT(*)'], actual_two))
except:
Log().warning('对【删除数】断言,断言结果--预期值%s != 实际值%s' % (expect_two['COUNT(*)'], actual_two))
raise
def testCase11(self, id=33):
"""发表评论"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'], key=data_test['key'], param=data_test['param'].replace("{0}", str(note_id)),
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'], data_test['way']))
apijson2 = json.loads(apijson)
sql = operate_excel.get_palce(case_num=id, case_name=MyTest.name)['sql']
actual_one = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).Perform()
actual_two = apijson2["data"]
try:
self.assertEqual(expect_one['comment_text'], actual_one, msg='预期和返回不一致')
Log().info('对【评论内容】断言,断言结果--预期值%s == 实际值%s' % (expect_one['comment_text'], actual_one))
except:
Log().warning('对【评论内容】断言,断言结果--预期值%s != 实际值%s' % (expect_one['comment_text'], actual_one))
raise
finally:
try:
self.assertIsNotNone(actual_two, msg='实际值不存在')
Log().info('已发送【%s】条评论' % (actual_two))
except:
Log().warning('评论发送失败')
raise
def Perform(self):
"""
增删改查操作,返回单个字段和记录
:return: {"key": "value"}
"""
db = self.connect_db()
cursor = db.cursor()
environment = operate_excel.get_palce(self.case_num, self.case_name)['db']
version = db.server_version
Log().info('成功登录%s环境数据库：%s，版本为：%s，执行SQL：%s' % (environment, self.database, version, self.sql))
if "SELECT" in self.sql or "select" in self.sql:
try:
cursor.execute(self.sql)
results = cursor.fetchall()
Log().info('查询结果：%s' % results[0][0])
return results[0][0]
except:
Log().info("Error: unable to fetch data")
raise
elif "UPDATE" in self.sql or "update" in self.sql:
try:
cursor.execute(self.sql)
db.commit()
Log().info("更新数据成功")
except:
db.rollback()
Log().info("Error：Has been rolled back")
raise
db.close()
def testCase6(self, id=9):
"""订单取消成功"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'].format(actual), key=data_test['key'], param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'], data_test['way']))
apijson2 = json.loads(apijson)
actual_one = apijson2["isSuccess"]
sql = operate_excel.get_palce(case_num=id, case_name=MyTest.name)['sql'].format(actual)
sleep(1)
actual_two = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).Perform()
try:
self.assertEqual(int(expect_one['isSuccess']), actual_one, msg='预期和返回不一致')
Log().info('对【订购结果】断言,断言结果--预期值%s == 实际值%s' % (expect_one['isSuccess'], actual_one))
except:
Log().warning('对【订购结果】断言,断言结果--预期值%s != 实际值%s' % (expect_one['isSuccess'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two['tradestatus']), actual_two, msg='预期和返回不一致')
Log().info('对【订单状态】断言,断言结果--支付成功预期值%s == 实际值%s' % (expect_two['tradestatus'], actual_two))
except:
Log().warning('对【订单状态】断言,断言结果--支付成功预期值%s != 实际值%s' % (expect_two['tradestatus'], actual_two))
raise
def more_perform(self):
"""
增删改查操作,返回多个字段和记录
:return: [{"key1": "value1", "key2", "value2"},{"key1": "value1", "key2", "value2"} ....]
"""
db = self.connect_db()
cursor = db.cursor()
environment = operate_excel.get_palce(self.case_num, self.case_name)['db']
version = db.server_version
Log().info('成功登录%s环境数据库：%s，版本为：%s，执行SQL：%s' % (environment, self.database, version, self.sql))
try:
cursor.execute(self.sql)
results = cursor.fetchall()
Log().info('sql查询结果：{0}'.format(results))
sql1 = self.sql.replace(' ', '')
find_keys = re.findall("^select(.+?)from", sql1)
keys = find_keys[0].split(",")
list_result = []
for i in results:
for num in range(len(i)):
dict_result = {}
dict_result[keys[num]] = i[num]
list_result.append(dict_result)
if len(results) == 1:
return dict_result
elif len(results) > 1:
return list_result
except:
Log().info("Error: unable to fetch data")
raise
db.close()
def testCase4(self, id=14):
"""绑定折扣码"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'],
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
apijson1 = apijson.replace('false', '"false"')
apijson2 = apijson1.replace('true', '"true"')
apijson3 = json.loads(apijson2)
actual_one = apijson3['data']['parentId']
actual_two = apijson3['data']['name']
sql = operate_excel.get_palce(case_num=11,
case_name=MyTest.name)['sql']
expect_two = operate_db.Operate_db(case_num=11,
sql=sql,
case_name=MyTest.name).Perform()
try:
self.assertEqual(int(expect_one['parentId']),
actual_one,
msg='预期和返回不一致')
Log().info('对【parentId】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['parentId'], actual_one))
except:
Log().warning('对【parentId】断言,断言结果--预期值%s != 实际值%s' %
(expect_one['parentId'], actual_one))
raise
finally:
try:
self.assertEqual(expect_two, actual_two, msg='预期和返回不一致')
Log().info('对【邀请人】断言,断言结果--预期值%s == 实际值%s' %
(expect_two, actual_two))
except:
Log().warning('对【邀请人】断言,断言结果--预期值%s != 实际值%s' %
(expect_two, actual_two))
raise
sleep(1)
sql1 = operate_excel.get_palce(case_num=8,
case_name=MyTest.name)['sql']
operate_db.Operate_db(case_num=8, sql=sql1,
case_name=MyTest.name).Perform()
def connect_db(self):
"""
连接数据库
:return:连接信息
"""
data = Getyaml().get_data(self.case_num, self.case_name)
self.database = operate_excel.get_palce(self.case_num, self.case_name)['database']
db1 = pymysql.connect(data[0], data[1], data[2],self.database ,charset='utf8')
Log().info("连接数据库成功")
return db1
def testCase03(self, id=2):
"""使用余额支付成功"""
#校验下单前收益明细详情
'''sql = 'SELECT commission from shop_commission where shop_id = 546082 limit 1'
re_comm_Cumulative,re_comm_sale,re_comm_today,banlance = operate_db.Operate_db(self,casenum=id,sql=sql).income_db()
print('下单前累计收益：' % re_comm_Cumulative)
print('下单前销售收益：'% re_comm_sale)
print('下单前今日收益：'% re_comm_today)
print('下单前账户余额：' % banlance)'''
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'].format(actual),
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
apijson2 = json.loads(apijson)
actual_one = apijson2["isSuccess"]
sql = operate_excel.get_palce(
case_num=id, case_name=MyTest.name)['sql'].format(actual)
actual_two = operate_db.Operate_db(case_num=id,
sql=sql,
case_name=MyTest.name).Perform()
try:
self.assertEqual(int(expect_one['isSuccess']),
actual_one,
msg='预期和返回不一致')
Log().info('对【订购结果】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['isSuccess'], actual_one))
except:
Log().warning('对【订购结果】断言,断言结果--预期值%s != 实际值%s' %
(expect_one['isSuccess'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two['tradestatus']),
actual_two,
msg='预期和返回不一致')
Log().info('对【订单状态】断言,断言结果--支付成功预期值%s == 实际值%s' %
(expect_two['tradestatus'], actual_two))
except:
Log().warning('对【订单状态】断言,断言结果--支付成功预期值%s != 实际值%s' %
(expect_two['tradestatus'], actual_two))
raise
def testCase04(self, id=3):
"""下单成功发送站内信"""
'''message_url = 'https://shop.m.showjoy.com.cn/api/message/count?userId=9082723'
with urllib.request.urlopen(message_url) as resp:
res = resp.read()
print('下单前消息数count：', res['count'])'''
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'],
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
apijson1 = json.loads(apijson)
actual_one = apijson1['data'][0]['content']
time = apijson1['data'][0]['time']
sql = operate_excel.get_palce(case_num=id,
case_name=MyTest.name)['sql']
excuse_sql = operate_db.Operate_db(case_num=id,
sql=sql,
case_name=MyTest.name).Perform()
json_dict = json.loads(excuse_sql)
messageSubLines = json_dict['messageSubLines'][0]['content']
actual_two = messageSubLines
try:
self.assertIn(expect_one['content'], actual_one, msg='预期和返回不一致')
Log().info('%s,对【下单成功消息内容】断言,断言结果--预期值%s == 实际值%s' %
(time, expect_one['content'], actual_one))
except:
Log().warning('%s,对【下单成功消息内容】断言,断言结果--预期值%s == 实际值%s' %
(time, expect_one['content'], actual_one))
raise
finally:
try:
self.assertEqual(expect_two['price'],
actual_two,
msg='预期和返回不一致')
Log().info('对【下单成功消息展示订单实付金额】断言,断言结果--预期值%s == 实际值%s' %
(expect_two['price'], actual_two))
except:
Log().warning('对【下单成功消息展示订单实付金额】断言,断言结果--预期值%s == 实际值%s' %
(expect_two['price'], actual_two))
raise
def testCase5(self, id=4):
"""订单详情收益和上级佣金"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
expect_three = operate_excel.change(asserexpect=data_test['expect3'])
expect_four = operate_excel.change(asserexpect=data_test['expect4'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'].format(actual), key=data_test['key'], param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'].format(actual), data_test['key'],
data_test['param'], data_test['way']))
apijson1 = json.loads(apijson)
actual_one = apijson1["data"]["tradePageInfoVO"]["orderDirectCommission"]
sql = operate_excel.get_palce(case_num=id, case_name=MyTest.name)['sql']
actual_com = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).more_perform()
actual_two = str(decimal.Decimal(actual_com[0]['commission']))
actual_three = str(decimal.Decimal(actual_com[1]['commission']))
actual_four = str(decimal.Decimal(actual_com[2]['commission']))
try:
self.assertEqual(float(expect_one['orderDirectCommission']), actual_one, msg='预期和返回不一致')
Log().info('对详情页【收益】断言,断言结果--预期值%s == 实际值%s' % (expect_one['orderDirectCommission'], actual_one))
except:
Log().warning('对详情页【收益】断言,断言结果--预期值%s != 实际值%s' % (expect_one['orderDirectCommission'], actual_one))
raise
finally:
try:
self.assertEqual(expect_two['invite'], actual_two, msg='预期和返回不一致')
Log().info('对邀请人【佣金】断言,断言结果--支付成功预期值%s == 实际值%s' % (expect_two['invite'], actual_two))
except:
Log().warning('对邀请人【佣金】断言,断言结果--支付成功预期值%s != 实际值%s' % (expect_two['invite'], actual_two))
raise
finally:
try:
self.assertEqual(expect_three['guwen'], actual_three, msg='预期和返回不一致')
Log().info('对客户代表/营销顾问【佣金】断言,断言结果--支付成功预期值%s == 实际值%s' % (expect_three['guwen'], actual_three))
except:
Log().warning('对客户代表/营销顾问【佣金】断言,断言结果--支付成功预期值%s != 实际值%s' % (expect_three['guwen'], actual_three))
raise
finally:
try:
self.assertEqual(expect_four['jinli'], actual_four, msg='预期和返回不一致')
Log().info('对市场经理【佣金】断言,断言结果--支付成功预期值%s == 实际值%s' % (expect_four['jinli'], actual_four))
except:
Log().warning('对市场经理【佣金】断言,断言结果--支付成功预期值%s != 实际值%s' % (expect_four['jinli'], actual_four))
raise
def testCase02(self, id=1):
"""直播推流成功"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('获取用例数据：%s' % data_test)
apijson2 = TestApi(url2=data_test['url'],
key=data_test['key'],
param=data_test['param'].replace(
"{0}", str(note_Id)),
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
print(apijson2)
apijson1 = json.loads(apijson2)
sleep(1)
sql = operate_excel.get_palce(case_num=id,
case_name=MyTest.name)['sql']
actual_one = apijson1["isSuccess"]
actual_two = operate_db.Operate_db(case_num=id,
sql=sql,
case_name=MyTest.name).Perform()
try:
self.assertEqual(int(expect_one['isSuccess']),
actual_one,
msg='预期和返回不一致')
Log().info('推流成功，对【isSuccess】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['isSuccess'], actual_one))
except:
Log().warning('推流失败，对【isSuccess】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['isSuccess'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two['live_status']),
actual_two,
msg='预期和返回不一致')
Log().info('对【直播状态】断言,断言结果--预期值%s == 实际值%s' %
(expect_two['live_status'], actual_two))
except:
Log().warning('对【直播状态】断言,断言结果--预期值%s != 实际值%s' %
(expect_two['live_status'], actual_two))
raise
def testCase06(self, id=5):
"""观众对主播进行关注/取关/互相关注"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('开始执行测试用例:%s' % data_test)
apijson = TestApi(url2=data_test['url'],
param=data_test['param'],
key=data_test['key'],
way=data_test['way']).selectway()
Log().info('请求传入的数据：url：%s,param：%s，key：%s，way：%s' %
(data_test['url'], data_test['param'], data_test['key'],
data_test['way']))
apijson1 = json.loads(apijson)
actual_one = apijson1["isSuccess"]
sleep(1)
sql = operate_excel.get_palce(
case_num=id, case_name=MyTest.name)['sql'].format(note_Id)
actual_two = operate_db.Operate_db(case_num=id,
sql=sql,
case_name=MyTest.name).Perform()
try:
self.assertEqual(int((expect_one)['isSuccess']),
actual_one,
msg='预期和返回不一致')
Log().info('关注/取关/互关成功，对【isSuccess】断言，断言结果--预期值%s==实际值%s' %
(expect_one['isSuccess'], actual_one))
except:
Log().warning('关注/取关/互关失败，对【isSuccess】断言，断言结果--预期值%s==实际值%s' %
(expect_one['isSuccess'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two['live_status']),
actual_two,
msg='预期和返回不一致')
Log().info('对【直播状态】断言,断言结果--预期值%s == 实际值%s' %
(expect_two['live_status'], actual_two))
except:
Log().warning('对【直播状态】断言,断言结果--预期值%s != 实际值%s' %
(expect_two['live_status'], actual_two))
raise
def testCase04(self, id=3):
"""观众加入直播"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
Log().info('获取用例数据：%s' % data_test)
apijson2 = TestApi(url2=data_test['url'].format(note_Id),
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
sql = operate_excel.get_palce(
case_num=id, case_name=MyTest.name)['sql'].format(note_Id)
expect_two = operate_db.Operate_db(case_num=id,
sql=sql,
case_name=MyTest.name).Perform()
print(apijson2)
apijson1 = json.loads(apijson2)
actual_one = apijson1["isSuccess"]
sleep(1)
actual_two = apijson1["data"]["pullUrl"]
try:
self.assertEqual(int(expect_one['isSuccess']),
actual_one,
msg='预期和返回不一致')
Log().info('加入成功，对【isSuccess】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['isSuccess'], actual_one))
except:
Log().warning('加入失败，对【isSuccess】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['isSuccess'], actual_one))
raise
finally:
try:
self.assertEqual(expect_two, actual_two, msg='预期和返回不一致')
Log().info('对【加入状态】断言,断言结果--预期值%s == 实际值%s' %
(expect_two, actual_two))
except:
Log().warning('对【加入状态】断言,断言结果--预期值%s != 实际值%s' %
(expect_two, actual_two))
raise
def testCase4(self, id=38):
"""编辑地址"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'], key=data_test['key'], param=data_test['param'].replace("{0}", str(address_id1)),
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'].replace("{0}", str(address_id1)), data_test['way']))
apijson2 = json.loads(apijson)
sql = operate_excel.get_palce(case_num=id, case_name=MyTest.name)['sql']
actual_one = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).Perform()
global address_id2
address_id2 = apijson2["data"]
try:
self.assertEqual(expect_one['fullName'], actual_one, msg='预期和返回不一致')
Log().info('重新生成地址id【%s】，对【fullName】断言,断言结果--预期值%s == 实际值%s' % (address_id2, expect_one['fullName'], actual_one))
except:
Log().warning('重新生成地址id【%s】，对【fullName】断言,断言结果--预期值%s != 实际值%s' % (address_id2, expect_one['fullName'], actual_one))
raise
def testCase09(self, id=15):
"""下单选择优惠劵"""
#consumption = 'SELECT CONSUMPTION_LIMIT FROM assets_coupon where USER_ID= 10464749 and IS_DELETE=0 and START_TIME <= NOW() and END_TIME > NOW() AND GMT_USED is null ORDER BY START_TIME '
#sku_price = 'select price from pc_sku where id = 226287'
data_test = operate_excel.data('zhuoxw1')[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'],
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
apijson1 = json.loads(apijson)
sql = operate_excel.get_palce(case_num=id,
case_name=MyTest.name)['sql']
quan = operate_db.Operate_db(case_num=id,
sql=sql,
case_name=MyTest.name).more_perform()
global actual_couponid, actual_couponworth
actual_couponid = quan['ID']
actual_couponworth = quan['WORTH']
try:
self.assertIsNotNone(actual_couponid, msg='实际值不存在')
Log().info('对【优惠劵列表】断言,获取第一张优惠劵id%s' % (actual_couponid))
except:
Log().warning('对【优惠劵列表】断言，无可用优惠劵')
raise
finally:
try:
self.assertEqual(int(expect_one['id']),
actual_couponid,
msg='预期和返回不一致')
Log().info('对【获取可用优惠劵】断言,断言结果--预期值{0} == 实际值{1}'.format(
expect_one['id'], actual_couponid))
except:
Log().warning('对【获取可用优惠劵】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['id'], actual_couponid))
raise
def testCase08(self, id=7):
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('测试用例开始执行：%s' % data_test)
apijson = TestApi(url2=data_test['url'].replace("{0}", str(note_Id)),
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入的数据：url:%s,key:%s,param:%s,way:%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
apijson1 = json.loads(apijson)
actual_one = apijson1["isSuccess"]
sql = operate_excel.get_palce(
case_num=id, case_name=MyTest.name)['sql'].format(note_Id)
actual_two = operate_db.Operate_db(case_name=MyTest.name,
case_num=id,
sql=sql).Perform()
try:
self.assertEqual(int((expect_one)['isSuccess']),
actual_one,
msg='预期和返回不一致')
Log().info('结束直播成功，对【isSuccess】断言，断言结果--预期值%s==实际值%s' %
(expect_one['isSuccess'], actual_one))
except:
Log().warning('结束直播失败，对【isSuccess】断言，断言结果--预期值%s==实际值%s' %
(expect_one['isSuccess'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two['live_status']),
actual_two,
msg='预期和返回不一致')
Log().info('对【直播状态】断言,断言结果--预期值%s == 实际值%s' %
(expect_two['live_status'], actual_two))
except:
Log().warning('对【直播状态】断言,断言结果--预期值%s != 实际值%s' %
(expect_two['live_status'], actual_two))
raise
def testCase07(self, id=29):
"""查看获赞和收藏数"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
sql = operate_excel.get_palce(case_num=id)['sql']
expects = operate_db.Operate_db(case_num=id, sql=sql, case_name=MyTest.name).more_perform()
expect_one = expects['sum(collect_num)']
expect_two = expects['sum(like_num)']
expect_three = expects['sum(share_num)']
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'], key=data_test['key'], param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' % (data_test['url'], data_test['key'],
data_test['param'], data_test['way']))
apijson2 = json.loads(apijson)
actual_one = apijson2["data"]["collectedNum"]
actual_two = apijson2["data"]["likedNum"]
actual_three = apijson2["data"]["sharedNum"]
try:
self.assertEqual(int(expect_one), actual_one, msg='预期和返回不一致')
Log().info('对【收藏数】断言,断言结果--预期值%s == 实际值%s' % (expect_one, actual_one))
except :
Log().warning('对【收藏数】断言,断言结果--预期值%s != 实际值%s' % (expect_one, actual_one))
raise
else:
Log().info('第1条断言成功')
finally:
try:
self.assertEqual(int(expect_two), actual_two, msg='预期和返回不一致')
Log().info('对【点赞数】断言,断言结果--预期值%s == 实际值%s' % (expect_two, actual_two))
except:
Log().warning('对【点赞数】断言,断言结果--预期值%s != 实际值%s' % (expect_two, actual_two))
raise
finally:
try:
self.assertEqual(int(expect_three), actual_three, msg='预期和返回不一致')
Log().info('对【被分享数】断言,断言结果--预期值%s == 实际值%s' % (expect_three, actual_three))
except :
Log().warning('对【被分享数】断言,断言结果--预期值%s != 实际值%s' % (expect_three, actual_three))
raise
def testCase08(self, id=9):
"""取消成功发送站内信"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'],
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
apijson1 = json.loads(apijson)
actual_one = apijson1['data'][0]['content']
sql = operate_excel.get_palce(case_num=id,
case_name=MyTest.name)['sql']
excuse_sql = operate_db.Operate_db(case_num=id,
sql=sql,
case_name=MyTest.name).Perform()
message_dict = json.loads(excuse_sql)
actual_two = message_dict['messageSubLines'][0]['content']
try:
self.assertEqual(expect_one['content'], actual_one, msg='预期和返回不一致')
Log().info('对【消息内容】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['content'], actual_one))
except:
Log().warning('对【消息内容】断言,断言结果--预期值%s != 实际值%s' %
(expect_one['content'], actual_one))
raise
finally:
try:
self.assertEqual(actual, actual_two, msg='预期和返回不一致')
Log().info('对【取消订单消息展示订单号】断言,断言结果--预期值%s == 实际值%s' %
(actual, actual_two))
except:
Log().warning('对【取消订单消息展示订单号】断言,断言结果--预期值%s == 实际值%s' %
(actual, actual_two))
raise
def testCase2(self, id=12):
"""短验注册登录成功"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'],
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
apijson1 = apijson.replace('false', '"false"')
apijson2 = json.loads(apijson1)
actual_one = apijson2['data']['mobileLoginUser'][0]["tel"]
actual_two = apijson2['data']['mobileLoginUser'][0]["userId"]
sql = operate_excel.get_palce(case_num=id,
case_name=MyTest.name)['sql']
expect_two = operate_db.Operate_db(case_num=9,
sql=sql,
case_name=MyTest.name).Perform()
try:
self.assertEqual(expect_one['tel'], actual_one, msg='预期和返回不一致')
Log().info('对【手机号】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['tel'], actual_one))
except:
Log().warning('对【手机号】断言,断言结果--预期值%s != 实际值%s' %
(expect_one['tel'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two), actual_two, msg='预期和返回不一致')
Log().info('对【userId】断言,断言结果--预期值%s == 实际值%s' %
(expect_two, actual_two))
except:
Log().warning('对【userId】断言,断言结果--预期值%s != 实际值%s' %
(expect_two, actual_two))
raise
def testCase09(self, id=8):
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
Log().info('测试用例开始执行：%s' % data_test)
apijson = TestApi(url2=data_test['url'].format(note_Id),
param=data_test['param'],
way=data_test['way'],
key=data_test['key']).selectway()
Log().info('请求传入的数据：url:%s,param:%s,way:%s,key:%s' %
(data_test['url'], data_test['param'], data_test['way'],
data_test['key']))
apijson1 = json.loads(apijson)
actual_one = apijson1["msg"]
sql = operate_excel.get_palce(case_name=MyTest.name,
case_num=id)['sql'].format(note_Id)
actual_two = operate_db.Operate_db(case_num=id,
case_name=MyTest.name,
sql=sql).Perform()
try:
self.assertEqual((expect_one)['msg'], actual_one, msg='预期和返回不一致')
Log().info('删除直播成功，对【msg】断言，断言结果--预期值%s==实际值%s' %
(expect_one['msg'], actual_one))
except:
Log().info('删除直播成功，对【msg】断言，断言结果--预期值%s==实际值%s' %
(expect_one['msg'], actual_one))
raise
finally:
try:
self.assertEqual(int(expect_two['COUNT(*)']),
actual_two,
msg='预期和返回不一致')
Log().info('对【删除结果】断言，断言结果--预期结果%s==实际值%s' %
(expect_two['COUNT(*)'], actual_two))
except:
Log().warning('对【删除结果】断言，断言结果--预期结果%s!=实际值%s' %
(expect_two['COUNT(*)'], actual_two))
def testCase06(self, id=6):
"""下单返优惠劵和佣金"""
data_test = operate_excel.data(case_name=MyTest.name)[id]
expect_one = operate_excel.change(asserexpect=data_test['expect1'])
expect_two = operate_excel.change(asserexpect=data_test['expect2'])
expect_three = operate_excel.change(asserexpect=data_test['expect3'])
expect_four = operate_excel.change(asserexpect=data_test['expect4'])
Log().info('获取用例数据:%s' % data_test)
apijson = TestApi(url2=data_test['url'],
key=data_test['key'],
param=data_test['param'],
way=data_test['way']).selectway()
Log().info('请求传入数据：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['param'],
data_test['way']))
apijson1 = json.loads(apijson)
actual_one = apijson1['data'][0]['templateId']
actual_two = apijson1['data'][0]['giftName']
actual_three = apijson1['data'][0]['discountPrice']
sql = operate_excel.get_palce(case_num=7, case_name=MyTest.name)['sql']
actual_four = operate_db.Operate_db(case_num=7,
sql=sql,
case_name=MyTest.name).Perform()
try:
self.assertEqual(int(expect_one['templateId']),
actual_one,
msg='预期和返回不一致')
Log().info('对【下单发放优惠劵id】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['templateId'], actual_one))
except:
Log().warning('对【下单发放优惠劵id】断言,断言结果--预期值%s == 实际值%s' %
(expect_one['templateId'], actual_one))
raise
finally:
try:
self.assertEqual(expect_two['giftName'],
actual_two,
msg='预期和返回不一致')
Log().info('对【下单发放优惠劵title】断言,断言结果--预期值%s == 实际值%s' %
(expect_two['giftName'], actual_two))
except:
Log().warning('对【下单发放优惠劵title】断言,断言结果--预期值%s == 实际值%s' %
(expect_two['giftName'], actual_two))
raise
finally:
try:
self.assertEqual(int(expect_three['worth']),
actual_three,
msg='预期和返回不一致')
Log().info('对【下单发放优惠劵面额】断言,断言结果--预期值%s == 实际值%s' %
(int(expect_three['worth']), actual_three))
except:
Log().warning('对【下单发放优惠劵面额】断言,断言结果--预期值%s == 实际值%s' %
(int(expect_three['worth']), actual_three))
raise
finally:
try:
self.assertEqual(float(
expect_four['orderDirectCommission']),
actual_four,
msg='预期和返回不一致')
Log().info('对【订单佣金】断言,断言结果--预期值%s == 实际值%s' %
(expect_four['orderDirectCommission'],
actual_four))
except:
Log().warning('对【订单佣金】断言,断言结果--预期值%s != 实际值%s' %
(expect_four['orderDirectCommission'],
actual_four))
raise
'''
