def test_c011_order_pay(self):
global log, log_exp, log_act
log_exp = Logger(logger="服务商平台_预期结果").getlog()
log_act = Logger(logger="服务商平台_实际结果").getlog()
log = Logger(logger="服务商平台").getlog()
try:
conn = MySQL().connect_order()
cur = conn.cursor()
sql = "select sp_order_id,order_id,pay_price from sp_order_info where sp_partner_id=" + spId + " and order_state=0"
print(sql)
cur.execute(sql)
ordering = cur.fetchone()[0:3]
sp_order_id = ordering[0]
order_id = ordering[1]
pay_price = ordering[2]
url = "http://sp.ejw.cn/order/v1/sp/" + spId + "/order/" + sp_order_id + "/paystageinfo"
print(url)
params = {"spEmpId": int(spEmpId), "spEmpName": "蒋涛", "orderId": order_id,
"spCusContractUrl": "https://bj.bcebos.com/v1/hnjing-test/d45fdb0150674e5baa969192921ad626.rar",
"stages": [{"spOrderStageNo": 1, "payDesc": "aaaa", "payAmount": int(pay_price)}]}
result_act = requests.post(url, data=json.dumps(params), headers=headers).status_code
result_exp = 200
self.assertEqual(result_exp, result_act, msg='接单失败')
log.info("接单成功")
except TypeError:
log.info("没有找到需要接单的订单")
def test_h001_search(self):
try:
conn = MySQL().connect_platform()
cur = conn.cursor()
sql = "select examine_auth_id from refund_examine where examine_state=0 and order_comp_id=" + cuComId
cur.execute(sql)
ordering = cur.fetchone()[0:1]
examine_auth_id = str(ordering[0])
print(examine_auth_id)
url = "http://admin.ejw.cn/platform/v1/arbitrate/" + examine_auth_id + "?curEmpId=" + adminEmpId
params = {
"examineState": 1,
"examineSuggest": "",
"refundAmount": 1,
"examineEmpId": int(adminEmpId),
"examineEmpName": cuEmpName,
"spOrderStageNo": 1,
"orderEmpId": int(cuEmpId),
"orderCompId": int(cuComId),
"useCost": 0,
"refundFee": 0
}
print(params)
result_act = requests.put(url,
data=json.dumps(params),
headers=headers)
# print(result_act.text)
result_exp = 200
self.assertEqual(result_exp, result_act.status_code, msg='发送仲裁失败')
log.info("申请仲裁成功")
except TypeError:
log.info("没有找到需要仲裁的订单")
def test_d003_pay(self):
try:
conn = MySQL().connect_order()
cur = conn.cursor()
sql = "select b.pay_id,a.sp_order_id,a.amount_Price, b.sp_order_stage_no, a.sp_product_code, a.sp_product_name, a.sp_product_spec_name from sp_order_info a, pay_stage_info b where a.order_state=1 and a.sp_partner_id=" + spId + " and b.pay_state=5 and a.sp_order_id=b.sp_order_id;"
cur.execute(sql)
ordering = cur.fetchone()[0:7]
pay_id = str(ordering[0])
sp_order_id = str(ordering[1])
amountPrice = ordering[2]
spOrderStageNo = ordering[3]
productCode = ordering[4]
productName = str(ordering[5])
productSpecName = ordering[6]
url = "http://cu.ejw.cn/platform/v1/order/" + sp_order_id + "/arbitrate/" + pay_id
print(url)
params = {"amountPrice": int(amountPrice), "spOrderStageNo": spOrderStageNo, "orderType": "1",
"productCode": productCode,
"productName": productName, "productSpecName": productSpecName, "spName": spName,
"spId": int(spId),
"cuName": cuComName, "orderCompId": int(cuComId), "orderEmpId": int(cuEmpId),
"cuEmpName": cuEmpName,
"applyDesc": "自动化-服务商不同意退款，已购产品货物没有送达"}
result_act = requests.post(url, data=json.dumps(params), headers=headers)
# print(result_act.text)
result_exp = 200
self.assertEqual(result_exp, result_act.status_code, msg='发送仲裁失败')
log.info("企业后台-订单管理-标准订单管理-申请仲裁: " + sp_order_id + "申请仲裁成功")
log_exp.info(result_exp)
log_act.info(result_act)
except TypeError:
log.info("没有找到需要仲裁的订单")
def test_c007_product_verify(self):
# 连接ps数据库
conn1 = MySQL().connect_platform()
cur1 = conn1.cursor()
sql = "select auth_id, record_id from product_auth t where t.sp_id=" + spId + " and t.`status`=0"
cur1.execute(sql)
try:
result_data = cur1.fetchone()[0:2]
auth_id = result_data[0]
record_id = result_data[1]
print(auth_id, record_id)
url_01 = "http://sp.ejw.cn/platform/v1/productauth/"
url = url_01 + str(record_id) + "?curEmpId=2121"
print(url)
params = {"contractId": auth_id, "contractName": "script.rar",
"contractBeginDate": "2018-07-13T00:00:00+08:00",
"contractValidDate": "2018-07-31T23:59:59+08:00",
"contractSpFile": "https://bj.bcebos.com/v1/hnjing-test/890d51e8ec26441da124f4f009cff36f.rar?authorization=bce-auth-v1%2Fed6cb82c3c054636aec25bdbc65d7c10%2F2018-07-13T01%3A51%3A01Z%2F-1%2F%2Ffcdc2fb8500561d8a195514e0d324075dd7c820a1fe7706defcd281460680773"}
result_act = requests.put(url, data=json.dumps(params), headers=headers)
log_act.info(result_act)
result_exp = 1
self.assertEqual(result_exp, int(result_act.text), msg="数据异常，产品授权不通过")
log.info("提交合同成功-待供应商审核")
except TypeError:
log.info("没有需要授权的产品信息")
def test_b004_search(self):
conn = MySQL().connect_platform()
cur = conn.cursor()
cur.execute("select record_id from product_auth where `status`=3;")
cur_data = cur.fetchone()
# print(cur_data)
if cur_data == None:
result_exp = None
self.assertEqual(result_exp, cur_data)
log.info("产品运营-产品授权审核-待审核-没有需要审核的产品信息")
else:
record_id = str(cur_data[0])
paramas = {"status": 5}
url_01 = 'http://admin.ejw.cn/platform/v1/productauth/'
url = url_01 + record_id + '/platformverify?curEmpId=' + adminEmpId
# print(url)
# 发送服务商接口请求
qykh_test_01 = requests.put(url,
data=json.dumps(paramas),
headers=headers)
# print(qykh_test_01.text)
result_act = qykh_test_01.status_code
result_exp = 200
# 判断当前返回码及字段值
self.assertEqual(result_exp, result_act, msg='审核失败：没有存在的企业或其它参数错误')
log.info("产品运营-产品授权审核-待审核-产品授权审核成功")
def test_c004_search(self):
try:
# 连接到数据库ps1（分支产品库）
conn = MySQL().connect_ps()
# 定义一个游标赋值给变量cur，cur才有权限去执行数据库
cur = conn.cursor()
# 数据库中查询服务商id为502，审核状态为1的产品
cur.execute(
'select sp_product_code from sp_product where sale_flag = 1 and sp_partner_id = 502 and examine_state = 0')
spProductCode = str(cur.fetchall()[0][0])
url_01 = 'http://sp.ejw.cn/platform/v1/product/'
url = url_01 + spProductCode + '/canel-verify'
# 发送下架取消接口请求
result_act = requests.delete(url, headers=headers).text
# 设置预期设为1
result_exp = 1
# 判断实际返回码是否与预期的一致
self.assertEqual(result_exp, int(result_act))
print(result_act)
global log, log_exp, log_act
log_exp = Logger(logger="服务商平台_预期结果").getlog()
log_act = Logger(logger="服务商平台_实际结果").getlog()
log = Logger(logger="服务商平台").getlog()
log_exp.info(result_exp)
log_act.info(result_act)
log.info(spProductCode + "下架审核取消操作成功")
except LookupError:
print("没有需要下架的方案数据")
def test_c003_order(self):
try:
conn = MySQL().connect_mall()
cur = conn.cursor()
sql = "select product_spec_uuid from shoping_info where sp_id=" + spId + " and emp_id=" + cuEmpId + " and comp_id=" + cuComId
cur.execute(sql)
uuid = cur.fetchone()[0]
url = "http://cu.ejw.cn/order/v1/cu/" + cuComId + "/order"
params = {
"order": {"cuPartnerName": cuComName, "cuEmpId": int(cuEmpId), "cuEmpName": cuEmpName,
"systemType": "0",
"resSystem": "1", "orderDesc": "自动化测试订单功能"},
"deliveryAddr": {"recName": "2222222000", "recPhone": "15000000000", "recPost": "333333",
"recAddr": "山东 济南 槐荫区 33333333333333333333333333333333", "deliveryDesc": ""},
"usePlatCouponInfo": [], "spOrderInfos": [
{"spSpecUuid": uuid, "amount": 1, "payType": "0", "invoiceType": "1",
"cusContractUrl": "https://bj.bcebos.com/v1/hnjing-test/c25ab9a8aadb41e7881ebcb9dceb2814.rar",
"otherContractUrl": "", "compQualifyInfos": [{"quaName": "成年人专用",
"quaImages": "https://bj.bcebos.com/v1/hnjing-test/d26a9fa28b6146b3ad27c1a228a5f885.jpg"}],
"useSkuCouponInfo": []}]}
result = requests.post(url, data=json.dumps(params), headers=headers)
result_exp_pro = 200
self.assertEqual(result_exp_pro, result.status_code, msg="请求参数异常或加入购物车失败")
log_exp.info(result_exp_pro)
log_act.info(result.text)
except TypeError:
log.info("数据库中没有需要下订单的数据")
def test_p003_search(self):
try:
# 连接到数据库ps1（分支产品库）
conn = MySQL().connect_ps()
# 定义一个游标赋值给变量cur，cur才有权限去执行数据库
cur = conn.cursor()
# 数据库中查询供应商id为502，产品状态为1（已上架）、审核状态为空或下架审核不通过
cur.execute(
'select cp_product_code,cp_product_name,cp_partner_id from cp_product where sale_flag = 1 and cp_partner_id = "' + cpComId + '" and examine_state=1')
# 定义查询数据库表中3个字段 cpProductCode，ProductName,partnerId
cur_data = cur.fetchone()[0:3]
print(cur_data, type(cur_data))
# 第一个字段赋给变量sp_product_code
cpProductCode = cur_data[0]
# 第二个字段赋给变量ProductName
ProductName = cur_data[1]
# 第三个字段赋给变量partnerId
partnerId = cur_data[2]
# 打印查询出来的cpProductCode，ProductName这2个字段内容
print(cpProductCode, ProductName)
# url地址
url_01 = 'http://cp.ejw.cn/cp/v1/partner/'
url_02 = url_01 + str(partnerId) + '/product/' + str(cpProductCode) + '/release?curEmpId='
url = url_01 + str(partnerId) + '/product/' + str(cpProductCode) + '/off?curEmpId=' + str(cpEmpId)
# 发送上架审核接口请求
result_act = requests.put(url, headers=headers).text
# 设置预期返回1
result_exp = 1
# 判断实际返回码是否与预期的一致
self.assertEqual(result_exp, int(result_act))
log_exp.info(result_exp)
log_act.info(result_act)
log.info(ProductName + "产品下架提交成功")
except TypeError:
log.info("没有需要下架的产品数据")
def test_p002_search(self):
try:
# 连接到数据库ps1（分支产品库）
conn = MySQL().connect_ps()
# 定义一个游标赋值给变量cur，cur才有权限去执行数据库
cur = conn.cursor()
# 数据库中查询供应商id为502，产品状态为0（已下架），审核状态为0（待上架审核）
cur.execute(
'select cp_product_code,cp_product_name,cp_partner_id from cp_product where sale_flag = 0 and cp_partner_id = "' + cpComId + '" and examine_state = 0')
# url地址，将产品编号设置为变量，将数据库查询出来的产品编号赋值给变量spProductCode
# 将查询出来的企业ID值赋值给变量cpProductCode
cpProductCode = str(cur.fetchall()[0][0])
# 拼接请求地址
url_01 = 'http://cp.ejw.cn/platform/v1/product/'
url = url_01 + str(cpProductCode) + '/canel-verify?curEmpId=' + str(cpEmpId)
# 打印请求地址，以便于核对请求地址是否拼接正确
print(url)
# 请求结果存入变量result_act
result_act = requests.delete(url, headers=headers).text
# 打印实际返回结果，以便于核对是否正确
print(result_act)
# 设置预期设为1
result_exp = 1
# 判断实际返回的内容是否与预期的一致
self.assertEqual(result_exp, int(result_act))
log_exp.info(result_exp)
log_act.info(result_act)
log.info(cpProductCode + "产品上架审核取消操作成功")
except LookupError:
log.info("没有需要取消上架产品的数据")
def test_p004_search(self):
try:
# 连接到数据库ps1（分支产品库）
conn = MySQL().connect_ps()
# 定义一个游标赋值给变量cur，cur才有权限去执行数据库
cur = conn.cursor()
# 数据库中查询供应商id为502，产品状态为1（已上架），审核状态为0（待下架审核）
cur.execute(
'select cp_product_code from cp_product where sale_flag = 1 and cp_partner_id = "' + cpComId + '" and examine_state = 0')
# 将查询出来的企业ID值赋值给变量cpProductCode
result_sql = cur.fetchone()[0:1]
cpProductCode = str(result_sql[0])
# 产品编号打印出来，以便于核对是否正确
log.info(cpProductCode)
# 拼接请求地址
url_01 = 'http://cp.ejw.cn/platform/v1/product/'
url = url_01 + str(cpProductCode) + '/canel-verify?curEmpId=' + str(cpEmpId)
# 打印请求地址，以便于核对请求地址是否拼接正确
log.info(url)
# 请求结果存入变量result_act
result_act = requests.delete(url, headers=headers).text
# 打印实际返回结果，以便于核对是否正确
log.info(result_act)
# 设置预期设为1
result_exp = 1
# 判断实际返回的内容是否与预期的一致
self.assertEqual(result_exp, int(result_act))
log_exp.info(result_exp)
log_act.info(result_act)
log.info(cpProductCode + "产品下架审核取消操作成功")
except TypeError:
log.info("没有需要取消产品下架审核的数据")
def test_c003station(self):
# 连接数据库
conn = MySQL().connect_emp_os()
cur = conn.cursor()
cur.execute('select station_id,station_name from station ')
station = cur.fetchone()[0:2]
station_id = str(station[0])
station_name = station[1]
url_bj = "http://emp.hnjing.com/emp_os/v1/station/"
url = url_bj + station_id
# 编辑后名称
stationName01 = ''.join(
random.sample(['1', '4', '3', '2', '5', '6'], 3))
stationName02 = '测试岗位林'
stationName = stationName02 + stationName01
params = {
"stationName": stationName,
"stationType": "0",
"departmentId": 95,
"modifier": oper_id
}
station_bj = requests.put(url,
data=json.dumps(params),
headers=headers)
result_bj = json.loads(station_bj.text)
values = result_bj["rowNum"]
result_exp = 1
self.assertEqual(result_exp, values)
log.info(stationName + "编辑岗位成功")
def test_c013_order_pay(self):
try:
conn = MySQL().connect_order()
cur = conn.cursor()
sql = "select b.pay_id,b.refund_Amount, b.sp_order_id from sp_order_info a, pay_stage_info b where a.order_state=1 and a.sp_partner_id=" + spId + " and b.pay_state=4 and a.sp_order_id=b.sp_order_id;"
cur.execute(sql)
ordering = cur.fetchone()[0:3]
sp_order_id = str(ordering[2])
refund_Amount = str(ordering[1])
pay_id = str(ordering[0])
url = "http://sp.ejw.cn/order/v1/partner/" + spId + "/order/" + sp_order_id + "/paystageinfo/" + pay_id
params = {
"nodeSuggest": "服务商不同意退款",
"payState": "5",
"spEmpId": spEmpId,
"spEmpName": "蒋涛",
"spPartnerName": "竞网自动化勿删",
"refundAmount": refund_Amount,
"useCost": "0.00",
"refundFee": "0.00"
}
result_act = requests.put(url,
data=json.dumps(params),
headers=headers).status_code
result_exp = 200
self.assertEqual(result_exp, result_act, msg='商家不退款失败')
log.info("工单管理-退款审核-商家不同意退款")
except TypeError:
log.info("没有找到不退款的订单")
def test_c001_search(self):
conn = MySQL().connect_platform()
cur = conn.cursor()
cur.execute('select type_id from qualify_type ORDER BY type_id DESC;')
sql_result = cur.fetchone()[0:1]
typeId = sql_result[0]
# 随机生成社会信用代码
tempName_01 = ''.join(
random.sample(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
4))
tempName_02 = '自资名称'
tempName = tempName_01 + tempName_02
url = 'http://admin.ejw.cn/platform/v1/qualifytemplate'
paramas = {
"typeId":
typeId,
"tempName":
tempName,
"tempImage":
"http://hnjing-test.bj.bcebos.com/v1/hnjing-test/34b04a41698c4dc28627a19d44801011.jpg"
}
# 发送服务商接口请求
zzmb = requests.post(url, data=json.dumps(paramas), headers=headers)
result_exp = 200
result_act = zzmb.status_code
# 判断当前返回码及字段值
self.assertEqual(result_exp, result_act, msg="新增模板失败，请检查失败原因")
log.info("系统管理-平台配置-资质模块设置-新增资质模块成功")
def test_d001_spsq_dsh(self):
conn = MySQL().connect_platform()
cur = conn.cursor()
cur.execute(
'select record_id,auth_id from product_auth where `status`= 3')
cur_data = cur.fetchone()
# print(type(cur_data))
result_exp = 200
if cur_data is None:
# print("执行A部分")
self.assertNotEqual(result_exp, cur_data, msg="没有需要授权的产品")
log.info("没有需要授权的产品")
else:
# print("执行B部分")
record_id = cur_data[0]
auth_id = cur_data[1]
print(record_id, auth_id)
url_01 = 'http://admin.ejw.cn/platform/v1/productauth/'
url = url_01 + str(record_id) + '/platformverify'
paramas = {"status": 5}
result = requests.put(url,
data=json.dumps(paramas),
headers=headers)
result_act = result.status_code
self.assertEqual(result_exp, result_act, msg="产品授权-审核不通过")
log.info("产品授权-审核通过")
def test_a002_role_del(self):
# 设置案例名称
conn = MySQL().connect_mall()
cur = conn.cursor()
# 查询出当前要删除案例的id信息
cur.execute('select case_id from class_case_info t where t.sp_id = "' + spId + '"')
case_id = str(cur.fetchall()[0][0])
url_01 = 'http://sp.ejw.cn/mall/v1/classcaseinfo/'
url = url_01 + case_id
result_act = requests.delete(url, headers=headers).text
result_exp = 1
self.assertEqual(result_exp, int(result_act), msg="删除失败")
log.info("案例删除成功")
def test_a003_case_search(self):
conn = MySQL().connect_mall()
cur = conn.cursor()
# 查询出当前要删除案例的id信息
sql = "select case_name from class_case_info t where t.sp_id =" + spId
cur.execute(sql)
case_name = str(cur.fetchall()[0][0])
url_01 = 'http://sp.ejw.cn/mall/v1/classcaseinfos?spId=' + spId + '&caseState=&pageSize=10&pageNo=1&caseName='
url = url_01 + case_name
result_act = requests.get(url, headers=headers).text
# print(case_name, result_act)
self.assertIn(case_name, result_act, msg="案例查询失败")
log.info(case_name + "查询成功")
def test_b002_cpmc_search(self):
# 连接数据库创建一个游标对象
conn = MySQL().connect_ps()
cur = conn.cursor()
sql = "select cp_product_name from cp_product t where t.cp_partner_id = " + cpComId
cur.execute(sql)
sql_result = cur.fetchone()[0:1]
cp_product_name = sql_result[0]
# 请求查询参数
url = "http://cp.ejw.cn/ps/v1/cpproducts?pageNum=1&pageSize=20&_sort=modifyDate%2Cdesc&cpPartnerId="+cpComId+"&cpProductName="+cp_product_name
# url = 'http://cp.ejw.cn/ps/v1/cpproducts?pageNum=1&pageSize=20&_sort=modifyDate%2Cdesc&cpPartnerId=502&cpProductName=%E8%87%AA%E5%8A%A8%E5%8C%96'
result_all = requests.get(url, headers=headers).text
self.assertIn(cp_product_name, result_all, "预期结果与实际结果不一致")
log.info("已存在的产品名称验证成功")
def test_c003_search(self):
try:
# 连接到数据库ps1（分支产品库）
conn = MySQL().connect_ps()
# 定义一个游标赋值给变量cur，cur才有权限去执行数据库
cur = conn.cursor()
# 数据库中查询服务商id为502，审核状态为-1的产品
cur.execute(
'select sp_product_code,sp_product_name from sp_product where sale_flag = 1 and sp_partner_id = 502 and examine_state = -1'
)
# 定义查询数据库表中2个字段sp_product_code，sp_product_name
cur_data = cur.fetchone()[0:2]
# 第一个字段赋给变量sp_product_code
spProductCode = str(cur_data[0])
# 第二个字段赋给变量sp_product_name
productName = cur_data[1]
# 打印查询出来的sp_product_code，sp_product_name这2个字段内容
print(spProductCode, productName)
# url地址
url = 'http://sp.ejw.cn/sp/v1/verify-saleflag'
# 参数信息
params = {
"spPartnerId": 502,
"spProductCode": spProductCode,
"productType": "group",
"verifyType": 2,
"createUser": 164,
"productName": productName,
"partnerName": "竞网自动化勿删"
}
# 发送上架审核接口请求
result_act = requests.post(url,
data=json.dumps(params),
headers=headers)
# 设置预期返回码200
result_exp = 200
# 实际返回码
result_act_act = result_act.status_code
# 判断实际返回码是否与预期的一致
self.assertEqual(result_exp, result_act_act)
global log, log_exp, log_act
log_exp = Logger(logger="服务商平台_预期结果").getlog()
log_act = Logger(logger="服务商平台_实际结果").getlog()
log = Logger(logger="服务商平台").getlog()
log_exp.info(result_exp)
log_act.info(result_act_act)
log.info(productName + "下架提交成功")
except LookupError:
print("没有需要下架的方案数据")
def test_b002_jn_del(self):
try:
conn = MySQL().connect_mall()
cur = conn.cursor()
# 查询出当前要删除案例的id信息
cur.execute('select policy_id from marketing_policy t where t.sp_id = "' + spId + '"')
jinnang = str(cur.fetchall()[0][0])
url_01 = 'http://sp.ejw.cn/mall/v1/marketingpolicy/'
url = url_01 + jinnang
case_delete_act = requests.delete(url, headers=headers).text
case_delete_exp = 1
self.assertEqual(case_delete_exp, int(case_delete_act), msg="案例删除失败")
log.info(jinnang + "删除成功")
except LookupError:
print("没有需要删除的锦囊数据")
def test_b002_shop(self):
try:
conn = MySQL().connect_mall()
cur = conn.cursor()
cur.execute(
'select rec_id from shoping_info t where t.sp_id = "' + spId + '" and t.emp_id= "' + cuEmpId + '"')
rec_id = str(cur.fetchone()[0])
url = "http://cu.ejw.cn/mall/v1/shopingcart/" + rec_id
result = requests.delete(url, headers=headers)
result_exp = "1"
self.assertEqual(result_exp, result.text, msg="企业平台删除购物车订单，删除失败")
log.info("企业平台删除购物车订单：操作成功")
log_exp.info(result_exp)
log_act.info(result.text)
except TypeError:
log.info("没有需要删除的购物车商品")
def test_b001_search(self):
try:
conn = MySQL().connect_portal()
cur = conn.cursor()
cur.execute("select partner_name from partner where `status`=0")
parnername = str(cur.fetchone()[0])
url_01 = 'http://admin.ejw.cn/portal/v1/partners?sort=%7B%22gmtCreate%22%3A%22desc%22%7D&status=0&pageNo=1&pageSize=10&partnerName='
url = url_01 + parnername
# 发送服务商接口请求
qykh_test_01 = requests.get(url, headers=headers)
qykh_test = qykh_test_01.text
# 判断当前返回码及字段值
self.assertIn(parnername, qykh_test, msg="没有查询到此用户信息")
log.info("企业客户管理-存在的用户查询成功")
except TypeError:
log.info("企业客户管理没有用户信息")
def test_a004_search(self):
conn = MySQL().connect_os()
cur = conn.cursor()
cur.execute(
"select partner_name from partner where partner_type = 0110;")
sql_result = cur.fetchone()[0:1]
parnername = sql_result[0]
url_01 = 'http://admin.ejw.cn/os/v1/partners?pageNo=1&pageSize=10&partnerType=0010%2C0011%2C0100%2C0101%2C0111%2C0110&partnerName='
url = url_01 + parnername
print(url)
# 发送服务商接口请求
qykh_test_01 = requests.get(url, headers=headers)
qykh_test = qykh_test_01.text
print(qykh_test)
self.assertIn(parnername, qykh_test, "查询的日志结果不一致")
log.info("合作伙伴管理-存在的信息查询成功")
def test_a004_bmyg_add(self):
try:
conn = MySQL.connect_os()
cur = conn.cursor()
sql = "select a.role_id,b.dep_id from role a,department b where a.app_name='cp' and a.partner_id=" + cpComId + " and b.partner_id=a.partner_id and depart_name="+"'自动化';"
cur.execute(sql)
sql_result = cur.fetchone()[0:2]
roles = sql_result[0]
depId = sql_result[1]
empName = ''.join(random.sample(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'x', 'j'], 6))
jobNo = ''.join(random.sample(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'], 6))
mobile_02 = ''.join(random.sample(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'], 8))
mobile_01 = '131'
mobile = mobile_01 + mobile_02
mail_01 = '@qq.com'
mail = mobile + mail_01
params = [
{"roles": [roles], "departments": [{"depId": depId, "position": 1}], "empName": empName, "jobNo": jobNo,
"email": mail, "phone": mobile, "status": 1,
"entryDate": "2018-05-02T16:00:00.000Z"}]
url = "http://cp.ejw.cn/cp/v1/partner/"+cpComId+"/employees"
result_act = requests.post(url, data=json.dumps(params), headers=headers)
result_exp = 200
self.assertEqual(result_exp, result_act.status_code)
log.info("企业设置-部门及员工管理, 新增员工结果如下：")
log_exp.info(result_exp)
log_act.info(result_act.text)
except TypeError:
log.info("数据库异常或角色、部门信息为空")
def test_e004employ(self):
# 连接数据库获取employee_id
conn = MySQL().connect_emp_os()
cur = conn.cursor()
cur.execute(
'select employee_id from employee where employee_name like "自动化测试%" and deleted = 1 and status != 2 '
)
employee_id = str(cur.fetchone()[0])
url_del = "http://emp.hnjing.com/emp_os/v1/employee/"
url = url_del + employee_id
emp_del = requests.delete(url, headers=headers)
result_del = json.loads(emp_del.text)
values = result_del["rowNum"]
result_exp = 1
self.assertEqual(result_exp, values)
log.info("员工离职")
def test_b003_jn_search(self):
try:
conn = MySQL().connect_mall()
cur = conn.cursor()
# 查询出当前要删除案例的id信息
cur.execute('select policy_Name from marketing_policy t where t.sp_id = "' + spId + '"')
result_exp = str(cur.fetchall()[0][0])
url_01 = "http://sp.ejw.cn/mall/v1/marketingpolicys?spId=" + spId + "&policyState=&pageNo=1&pageSize=10&policyName="
url = url_01 + result_exp
result_act = requests.get(url, headers=headers).text
self.assertIn(result_exp, result_act, msg="案例名称查询失败")
log.info("查询营销锦囊成功，返回营销锦囊记录，营销锦囊名称为：" + result_exp)
log_exp.info(result_exp)
log_act.info(result_act)
except TypeError:
log.info("查询列表数据为空")
def test_c005_product_serach(self):
conn = MySQL().connect_ps()
cur = conn.cursor()
sql = "select sp_product_name from sp_product t where t.sp_partner_id=" + spId + " order by create_date desc"
cur.execute(sql)
productName = str(cur.fetchone()[0])
log_exp.info(productName)
url_01 = "http://sp.ejw.cn/ps/v1/spproducts?buyType=&_sort=modifyDate%2Cdesc&pageSize=20&pageNum=1&spPartnerId=" \
+ spId + "&spProductName="
url = url_01 + productName
product_search = requests.get(url, headers=headers)
# print(product_search.text)
result_act = product_search.text
log_act.info(result_act)
self.assertIn(productName, result_act, msg="查询的产品名字不存在")
log.info("已有产品名称查询成功")
def test_b003_jn_search(self):
conn = MySQL().connect_mall1('conn')
cur = conn.cursor()
sql_data = '502'
# 查询出当前要删除案例的id信息
cur.execute(
'select policy_Name from marketing_policy t where t.sp_id = "' +
sql_data + '"')
result_exp = str(cur.fetchall()[0][0])
url_01 = 'http://sp.ejw.cn/mall/v1/marketingpolicys?spId=502&policyState=&pageNo=1&pageSize=10&policyName='
url = url_01 + result_exp
result_act = requests.get(url, headers=headers).text
log_exp.info(result_exp)
log_act.info(result_act)
self.assertIn(result_exp, result_act, msg="案例名称查询失败")
log.info("案例名称查询成功")
def test_a001(self):
token = Zpt().cu_login()
headers = {
'Content-Type': 'application/json;charset=UTF-8',
'token': token
}
conn = MySQL.connect_mall()
cur = conn.cursor()
sql = "select t.product_uuid, t.product_spec_uuid from shoping_info t where t.sp_id=" + spId + " and emp_id=" + \
cuEmpId
cur.execute(sql)
sql_result = cur.fetchone()[0:2]
productUuid = sql_result[0]
productSpecUuid = sql_result[1]
url = "http://www.ejw.cn/shopingcart/" + cuComId
params = {
"productUuid": productUuid,
"productSpecUuid": productSpecUuid,
"spId": int(spId),
"compId": int(cuComId),
"empId": int(cuEmpId)
}
result = requests.post(url, data=json.dumps(params), headers=headers)
result_exp = 200
# print(result_exp_pro, result_act_pro)
self.assertEqual(result_exp, result.status_code, msg="请求参数异常或加入购物车失败")
print("外商城商品加入购物车成功", result.text)
def test_b007_search(self):
try:
conn = MySQL().connect_portal()
cur1 = conn.cursor()
cur1.execute(
'select partner_id from partner where `status`=2 ORDER BY gmt_create DESC;'
)
par_result = cur1.fetchone()
partner_id = par_result[0]
url_01 = "http://admin.ejw.cn/portal/v1/partnerall/"
url = url_01 + str(partner_id)
result_act = requests.delete(url, headers=headers).status_code
result_exp = 200
self.assertEqual(result_exp, result_act, msg="返回响应码不一致，请检查是否有错")
log.info("用户运营-企业客户管理-企业审核不通过-删除通过")
except TypeError:
log.info("数据库查询信息为空,没有需要删除的企业客户")
def test_a004(self):
token = Zpt().cu_login()
headers = {
'Content-Type': 'application/json;charset=UTF-8',
'token': token
}
try:
# 获取当前已加入购物车的spid
# conn_mail = MySQL().connect_mall()
# cur_mail = conn_mail.cursor()
# sql = "select sp_id from shoping_info where comp_id =" + cuComId + " and emp_id= " + cuEmpId + " and sp_id=" + spId
# cur_mail.execute(sql)
# result_sql = cur_mail.fetchone()[0:1]
# sp_id = result_sql[0]
# print(sp_id)
# 查询需要付款的订单
conn = MySQL().connect_order()
cur = conn.cursor()
sql = "select b.sp_order_id,b.sp_order_stage_no from sp_order_info a, pay_stage_info b where a.sp_partner_id=" + spId + " and a.sp_order_id=b.sp_order_id and b.pay_state=0;"
print(sql)
cur.execute(sql)
ordering = cur.fetchone()[0:2]
sp_order_id = str(ordering[0])
sp_order_stage_no = str(ordering[1])
url = "http://cu.ejw.cn/order/v1/cu/" + cuComId + "/pay/" + sp_order_id + "/stage/" + sp_order_stage_no
print(url)
params = {
"cuPartnerName": cuComName,
"cuEmpId": int(cuEmpId),
"cuEmpName": cuEmpName,
"cuAccountPwd": "a123456",
"cuEntrustUrl": "",
"cuAccountId": "1835115000108339",
"cuAccountName": cuComName
}
print(params)
result_act = requests.post(url,
data=json.dumps(params),
headers=headers)
result_exp = 200
self.assertEqual(result_exp, result_act.status_code, msg='接单失败')
print("企业后台-订单管理-标准订单管理-付款", result_exp, result_act.text)
except TypeError:
print("没有找到需要付款的订单")
