def test_1_shuj(self, data):
'''
计算强评价
维持保证金
注意：取参数时，需要查看execl是否有多余的空格
:param data:
:return:
'''
test = Test_Login(single)
token_test = test.test_log()
quantity = float(data['quantity(数量)'])
lever = int(data['lever(杠杆)'])
bs_flag = int(data['bs_flag(1买跌/2买涨)'])
price = data['price(限价单)']
order_type = int(data['order_type(订单类型1市场 2限价)'])
contract_id = data['contract_id(交易对)']
paramt_type = data['期望请求方式']
#1、市场价买涨算强平价格计算
#2、多仓强平价格 = 开仓价格 * (1 - 起始保证金率 + 维持保证金率)
#查询维持保证金率
sql = ('SELECT * FROM pc_risk_limit')
maintenance_margin = db_link.get_one(sql) #查询维持保证金率第一条数据
maintenance = float(
maintenance_margin['maintenance_margin_rate']) #取出维持保证金率
# #起始保证金率(1 - 1 / lever)
Strong_parity = price * (1 - 1 / lever + maintenance)
print('强平价', Strong_parity)
paramt = {
'quantity': quantity,
'lever': lever,
'bs_flag': bs_flag,
'price': price,
'order_type': order_type,
'contract_id': contract_id,
'price': price
} #拼接参数
print(paramt)
print(type(token_test['token']))
for i in token_test['token']: #循环里面token_test的值
type_c = token_test['contract_type']
print(type_c)
if type_c[0] == 2: # 判断是否全仓还是逐仓
contract_type = {"contract_type": '1'} # 是逐仓切换成全仓
contract = requests_single(
url='https://t01-mapi.deepcoin.pro/pc/set-contract-type',
requersts_type='post',
paramt=contract_type,
headers=i) #切换仓位接口
print(contract.getJson())
print(i)
sql_usdt_Balance = requests_single(
url='https://t01-mapi.deepcoin.pro/pc/balance',
requersts_type='get',
paramt=paramt,
headers=i) #查看余额接口
usdt_Balance = sql_usdt_Balance.getJson()
totoal = usdt_Balance.get('retData').get('futures_usdt_balance')
print("查看总额度", totoal)
head = {
"Content-Type": "application/x-www-form-urlencoded",
"token": i
} #传token
create_order_api = requests_single(url=data['url'],
requersts_type=data['期望请求方式'],
paramt=paramt,
headers=i) #委托下单接口
create_order_api_json = create_order_api.getJson() #取返回joson值里面的值
retMsg = create_order_api_json.get('retMsg')
try:
self.assertEqual(retMsg, '委托下单成功', msg='下单失败')
except Exception as e:
print(e)
plan_order_id = create_order_api_json.get('retData').get(
'plan_order_id') #取出订单id
sql_plan_order_id = "SELECT * FROM `pc_order` WHERE order_id='%s'" % (
plan_order_id) #根据订单id查询订单表
print(sql_plan_order_id)
plan_order = db_link.get_one(sql_plan_order_id)
print('查询订单', plan_order)
'''
计算execl和落库的数据是否一致
'''
try:
self.assertEqual(price,
plan_order['price'],
msg='下单价格跟数据库价格不一致')
self.assertEqual(lever,
plan_order['lever'],
msg='下单杠杆跟数据库价格不一致')
self.assertEqual(bs_flag,
plan_order['bs_flag'],
msg='下单方向跟数据库价格不一致')
self.assertEqual(order_type,
plan_order['order_type'],
msg='下单订单类型跟数据库价格不一致')
self.assertEqual(order_type,
plan_order['order_type'],
msg='下单订单类型跟数据库价格不一致')
except Exception as e:
print(e)
'''
计算起始保证金
'''
amount = quantity * price / lever # 计算起始保证金
try:
self.assertEqual(
round(amount, 12),
float(plan_order['amount']),
msg='保证金不相等') #取出数据库的保证金，数据库中的保证金对比是否相等，如果有异常包住，继续
except Exception as e:
print(e)
'''
计算预收开仓手续费（预收开仓和平仓一致）
计算预收平仓手续费
'''
symbol = "SELECT * FROM `pc_contract` WHERE symbol='BTC/USDT'" #计算预收开仓手续费，取taker来计算的
symbol_BTC = db_link.get_one(symbol) #取taker
taker_fee_ratio = quantity * price * float(
symbol_BTC['taker_fee_ratio']) #计算开仓保证金.开仓价格*数量*起始保证金率
try:
#判断开仓手续费是否相等
self.assertEqual(taker_fee_ratio, plan_order['open_fee'])
# 判断平仓手续费是否相等
self.assertEqual(taker_fee_ratio, plan_order['close_fee'])
# 判断杠杆是否相等
self.assertEqual(lever, plan_order['lever'])
except Exception as e:
print(e)
'''
计算账户扣减金额是否正确
'''
Balance = amount + taker_fee_ratio * 2
print("下单金额", Balance)
sql_usdt_Balance = requests_single(
url='https://t01-mapi.deepcoin.pro/pc/balance',
requersts_type='get',
paramt=paramt,
headers=i)
usdt_Balance = sql_usdt_Balance.getJson()
keyong = usdt_Balance.get('retData').get('futures_usdt_balance')
print('keyong', keyong)
print(totoal, )
shengyu = float(totoal) - float(keyong)
print(
float(totoal.replace(",", "")) -
float(keyong.replace(",", "")))
print("正确扣减的金额", shengyu)
try:
self.assertEqual(shengyu, Balance, msg='扣减额度不正确')
except Exception as e:
print(e)
'''
维持保证金 = 合约数量*开仓价格*维持保证金率
'''
weichi = quantity * price * maintenance
print("维持保证金", weichi)
def test_1_shuj(self,data):
test = Test_Login(rise)
token_test = test.test_log()
'''
计算强评价
维持保证金
注意：取参数时，需要查看execl是否有多余的空格
:param data:
:return:
'''
quantity=float(data['quantity(数量)'])
lever=float(data['lever(杠杆)'])
bs_flag=int(data['bs_flag(1买跌/2买涨)'])
price=data['price(限价单)']
order_type=int(data['order_type(订单类型1市场 2限价)'])
contract_id=data['contract_id(交易对)']
paramt_type=data['期望请求方式']
print(lever)
#1、市场价买涨算强平价格计算
#2、多仓强平价格 = 开仓价格 * (1 - 起始保证金率 + 维持保证金率)
#查询维持保证金率
sql=('SELECT * FROM pc_risk_limit')
maintenance_margin=db_link.get_one(sql)#查询维持保证金率第一条数据
maintenance=float(maintenance_margin['maintenance_margin_rate'])#取出维持保证金率
# #起始保证金率(1 - 1 / lever-维持保证金率)
Strong_parity=price*(1-1/lever-maintenance)
print('强平价',Strong_parity)
paramt={'quantity':quantity,'lever':lever,'bs_flag':bs_flag,'price':price,'order_type':order_type,'contract_id':contract_id} #拼接参数
print(paramt)
for i in token_test['token']:#循环里面token_test的值
sql_usdt_Balance = requests_single(url='https://t01-mapi.deepcoin.pro/pc/balance', requersts_type='get',
paramt=paramt, headers=i)
usdt_Balance = sql_usdt_Balance.getJson()
totoal = usdt_Balance.get('retData').get('futures_usdt_balance')
print(i)
head = {"Content-Type": "application/x-www-form-urlencoded", "token": i}#传token
api=requests_single(url=data['url'],requersts_type=data['期望请求方式'],paramt=paramt,headers=i)
api_json=api.getJson()#取返回joson值里面的值
retMsg=api_json.get('retMsg')
try:
self.assertEqual(retMsg, '委托下单成功', msg='下单失败')
except Exception as e:
print(e)
plan_order_id1=api_json.get('retData').get('plan_order_id')#取出订单id
sql_plan_order_id="SELECT * FROM `pc_order` WHERE order_id='%s'"%(plan_order_id1)#根据订单id查询订单表
print(sql_plan_order_id)
plan_order=db_link.get_one(sql_plan_order_id)
print('查询订单',plan_order)
'''
计算execl和落库的数据是否一致
'''
try:
self.assertEqual(price, plan_order['price'], msg='下单价格跟数据库价格不一致')
self.assertEqual(lever, plan_order['lever'], msg='下单杠杆跟数据库价格不一致')
self.assertEqual(bs_flag, plan_order['bs_flag'], msg='下单方向跟数据库价格不一致')
self.assertEqual(order_type, plan_order['order_type'], msg='下单订单类型跟数据库价格不一致')
self.assertEqual(order_type, plan_order['order_type'], msg='下单订单类型跟数据库价格不一致')
except Exception as e:
print(e)
print(type(quantity),type(price),type(lever))
'''
计算起始保证金是否相等
'''
amount=quantity*price/lever# 计算起始保证金
try:
self.assertEqual(round(amount,4),float(plan_order['amount']),msg='保证金不相等')#取出数据库的保证金，数据库中的保证金对比是否相等，如果有异常包住，继续
except Exception as e:
print(e)
symbol = "SELECT * FROM `pc_contract` WHERE symbol='BTC/USDT'"#计算预收开仓手续费，用taker来计算的
print(symbol)
symbol_BTC = db_link.get_one(symbol)
taker_fee_ratio = quantity * price *float(symbol_BTC['taker_fee_ratio'])#取出开仓手续费计算开仓保证金.开仓价格*数量*起始保证金率
try:
#判断开仓手续费是否相等
self.assertEqual(taker_fee_ratio,plan_order['open_fee'])
# 判断平仓手续费是否相等
self.assertEqual(taker_fee_ratio,plan_order['close_fee'])
# 判断杠杆是否相等
self.assertEqual(lever, plan_order['lever'])
except Exception as e:
print(e)
Balance = amount + taker_fee_ratio * 2
sql_usdt_Balance = requests_single(url='https://t01-mapi.deepcoin.pro/pc/balance', requersts_type='get',
paramt=paramt, headers=i)
usdt_Balance = sql_usdt_Balance.getJson()
keyong = usdt_Balance.get('retData').get('futures_usdt_balance')
print('keyong', keyong)
shengyu =float(totoal) - float(keyong)
print(float(totoal) - float(keyong))
print("剩余余额", shengyu)
try:
self.assertEqual(shengyu, Balance, msg='扣减额度不正确')
except Exception as e:
print(e)
def test_1_shuj(self):
test = Test_Login(single)
token_test = test.test_log()
'''
取开多的数据
'''
data1_url = excel.exexl('url') # 取url
host_duo = data1_url[0]["url"] # 取URL的第一个值
pramnt_pramnt = excel.exexl('参数') # 取url
pramnt_duo = pramnt_pramnt[0]["参数"]
pramnt1_dict_duo = eval(pramnt_duo)
print(pramnt1_dict_duo)
qingqiu_duo = excel.exexl('请求方式') # 取url
qingqiu_duo1 = qingqiu_duo[0]["请求方式"]
# 取第二组数据
host_duo2 = data1_url[1]["url"] # 取URL的第一个值
print(host_duo2)
pramnt_duo2 = pramnt_pramnt[1]["参数"]
pramnt2_dict_duo = eval(pramnt_duo2)
print(pramnt2_dict_duo)
qingqiu2_duo = qingqiu_duo[1]["请求方式"]
#取第三组数据
host_duo3 = data1_url[2]["url"] # 取URL的第一个值
print(host_duo3)
pramnt_duo3 = pramnt_pramnt[2]["参数"]
qingqiu3_duo = qingqiu_duo[2]["请求方式"]
#取第四组数据
host_duo4 = data1_url[3]["url"] # 取URL的第一个值
print(host_duo4)
pramnt_duo4 = pramnt_pramnt[3]["参数"]
pramnt4_dict_duo = eval(pramnt_duo4)
print(pramnt4_dict_duo)
qingqiu4_duo = qingqiu_duo[3]["请求方式"]
sql = ('SELECT * FROM pc_risk_limit')
maintenance_margin = db_link.get_one(sql) # 查询维持保证金率第一条数据
maintenance = maintenance_margin['maintenance_margin_rate'] # 取出维持保证金率
for i in token_test['token']:
print("-----------------------------------")
type_c = token_test['contract_type']
if type_c[0] == 1: # 判断是否全仓还是逐仓
contract_type = {"contract_type": '2'} # 是全仓换成逐仓
contract = requests_single(
url='https://t01-mapi.deepcoin.pro/pc/set-contract-type',
requersts_type='post',
paramt=contract_type,
headers=i) # 切换仓位接口
contract_list = contract.getJson()
contract_list.get('retData')['user']['contract_type']
sql_usdt_Balance = requests_single(
url='https://t01-mapi.deepcoin.pro/pc/balance',
requersts_type='get',
paramt='1111',
headers=i) # 查看余额接口
usdt_Balance = sql_usdt_Balance.getJson()
totoal = usdt_Balance.get('retData').get('futures_usdt_balance')
print("查看总额度", totoal)
#下单
api_json = requests_single(url=host_duo,
requersts_type=qingqiu_duo1,
paramt=pramnt1_dict_duo,
headers=i)
plan_order_id = api_json.getJson()
order_Msg1 = plan_order_id.get('retMsg') # 取出订单id
plan_order1 = plan_order_id.get('retData').get('plan_order_id')
try:
self.assertEqual(order_Msg1, '委托下单成功', msg='委托下单失败')
except Exception as e:
print(e)
sql_plan_order_id_to = "SELECT * FROM `pc_order` WHERE order_id='%s'" % (
plan_order1) # 根据订单id查询订单表
print(sql_plan_order_id_to)
plan_order_to = db_link.get_one(sql_plan_order_id_to)
print('查询订单', plan_order_to)
'''
计算execl和落库的数据是否一致
'''
amount_1 = float(pramnt1_dict_duo['quantity']) * float(
pramnt1_dict_duo['price']) / float(
pramnt1_dict_duo['lever']) # 计算起始保证金
print('execl计算起始保证金', amount_1)
self.assertEqual(
pramnt1_dict_duo['price'],
str(plan_order_to['price']).rstrip('0').strip('.'),
msg='参数1下单价格跟数据库价格不一致')
self.assertEqual(
pramnt1_dict_duo['lever'],
str(plan_order_to['lever']).rstrip('0').strip('.'),
msg='下单杠杆跟数据库价格不一致')
self.assertEqual(int(pramnt1_dict_duo['bs_flag']),
plan_order_to['bs_flag'],
msg='下单方向跟数据库价格不一致')
self.assertEqual(int(pramnt1_dict_duo['order_type']),
plan_order_to['order_type'],
msg='下单订单类型跟数据库价格不一致')
self.assertEqual(round(amount_1, 4),
float(plan_order_to['amount']),
msg='保证金不相等')
'''
计算预收开仓手续费（预收开仓和平仓一致）
计算预收平仓手续费
'''
symbol = "SELECT * FROM `pc_contract` WHERE symbol='BTC/USDT'" # 计算预收开仓手续费，取taker来计算的
symbol_BTC = db_link.get_one(symbol)
taker_fee_ratio_1 = plan_order_to['quantity'] * plan_order_to[
'price'] * symbol_BTC[
'taker_fee_ratio'] # 取出taken手续费计算开仓保证金.开仓价格*数量*起始保证金率
try:
# 判断开仓手续费是否相等
self.assertEqual(taker_fee_ratio_1, plan_order_to['open_fee'])
# 判断平仓手续费是否相等
self.assertEqual(taker_fee_ratio_1, plan_order_to['close_fee'])
# 判断杠杆是否相等
self.assertEqual(taker_fee_ratio_1['lever'],
plan_order_to['lever'])
except Exception as e:
print(e)
# 下单第二组数据
print(
'***********************************************************************************'
)
api_json_2 = requests_single(url=host_duo2,
requersts_type=qingqiu2_duo,
paramt=pramnt2_dict_duo,
headers=i)
plan_order_id_2 = api_json_2.getJson()
order_Msg_2 = plan_order_id_2.get('retMsg') # 取出订单id
plan_order_2 = plan_order_id_2.get('retData').get('plan_order_id')
try:
self.assertEqual(order_Msg_2, '委托下单成功', msg='委托下单失败')
except Exception as e:
print(e)
sql_plan_order_id_to_2 = "SELECT * FROM `pc_order` WHERE order_id='%s'" % (
plan_order_2) # 根据订单id查询订单表
print(sql_plan_order_id_to_2)
plan_order_to_2 = db_link.get_one(sql_plan_order_id_to_2)
print('查询订单', plan_order_to_2)
'''
计算execl和落库的数据是否一致
'''
amount_3 = float(pramnt2_dict_duo['quantity']) * float(
pramnt2_dict_duo['price']) / float(
pramnt2_dict_duo['lever']) # 计算起始保证金
print('execl计算起始保证金', amount_3)
self.assertEqual(pramnt2_dict_duo['price'],
slice_Character.split_to(
plan_order_to_2['price']),
msg='参数1下单价格跟数据库价格不一致')
self.assertEqual(
pramnt2_dict_duo['lever'],
str(plan_order_to_2['lever']).rstrip('0').strip('.'),
msg='下单杠杆跟数据库价格不一致')
self.assertEqual(int(pramnt2_dict_duo['bs_flag']),
plan_order_to_2['bs_flag'],
msg='下单方向跟数据库价格不一致')
self.assertEqual(int(pramnt2_dict_duo['order_type']),
plan_order_to_2['order_type'],
msg='下单订单类型跟数据库价格不一致')
taker_fee_ratio_2 = plan_order_to_2['quantity'] * plan_order_to_2[
'price'] * symbol_BTC[
'taker_fee_ratio'] # 取出taken手续费计算开仓保证金.开仓价格*数量*起始保证金率
# 判断开仓手续费是否相等
self.assertEqual(taker_fee_ratio_2, plan_order_to_2['open_fee'])
# 判断平仓手续费是否相等
self.assertEqual(taker_fee_ratio_2, plan_order_to_2['close_fee'])
# 判断杠杆是否相等
self.assertEqual(
pramnt2_dict_duo['lever'],
slice_Character.split_to(plan_order_to_2['lever']))
#查询持仓列表
print(
'----------------------------------------------------------------------------------------------'
)
api_json3 = requests_single(url=host_duo3,
requersts_type=qingqiu3_duo,
paramt='11111',
headers=i)
plan_order_id3 = api_json3.getJson()
for xia in range(0, 2):
print(plan_order_id3.get('retData')['list'][xia])
plan_order3 = []
plan_order3.append(
plan_order_id3.get('retData')['list'][xia]['order_id'])
before_price = plan_order_id3.get(
'retData')['list'][xia]['force_price']
print('调整前的强平价', before_price)
# 增加杠杆取第四组数据(增加两次杠杆)
print(
'-----------------------------------------------------------------------------------'
)
for s in plan_order3:
update_redis.redis_value('8500')
print(type(pramnt4_dict_duo))
dict_to = {'trade_order_id': s}
pr = {}
pr.update(pramnt4_dict_duo)
pr.update(dict_to)
api_json4 = requests_single(url=host_duo4,
requersts_type=qingqiu4_duo,
paramt=pr,
headers=i)
req = api_json4.getJson()
req.get('retMsg')
# 查询持仓列表
print(
'----------------------------------------------------------------------------------------------'
)
api_json5 = requests_single(url=host_duo3,
requersts_type=qingqiu3_duo,
paramt='11111',
headers=i)
plan_order_id5 = api_json5.getJson()
for xia1 in range(0, 1):
print(
"调整杠杆后的强评价",
plan_order_id5.get('retData')['list'][xia1]
['force_price'])
print("订单id", plan_order_id)
sql_trade_order_id = "select * from pc_trade_order where order_id in ('%s')" % (
str(s)) # 根据订单id查询订单表
print(sql_trade_order_id)
order_id = db_link.get_one(sql_trade_order_id)
def test_1_shuj(self):
test = Test_Login(rise)
token_test = test.test_log()
'''
取开多的数据
'''
data1_url = excel.exexl('url') # 取url
host_duo = data1_url[0]["url"] # 取URL的第一个值
pramnt_pramnt = excel.exexl('参数') # 取url
pramnt_duo = pramnt_pramnt[0]["参数"]
pramnt1_dict_duo = eval(pramnt_duo)
print(pramnt1_dict_duo)
qingqiu_duo = excel.exexl('请求方式') # 取url
qingqiu_duo1 = qingqiu_duo[0]["请求方式"]
# 取第二组数据
host_duo2 = data1_url[1]["url"] # 取URL的第一个值
print(host_duo2)
pramnt_duo2 = pramnt_pramnt[1]["参数"]
pramnt2_dict_duo = eval(pramnt_duo2)
print(pramnt2_dict_duo)
qingqiu2_duo = qingqiu_duo[1]["请求方式"]
# 取第三组数据
host_duo3 = data1_url[2]["url"] # 取URL的第一个值
print(host_duo3)
pramnt_duo3 = pramnt_pramnt[2]["参数"]
pramnt3_dict_duo = eval(pramnt_duo3)
qingqiu3_duo = qingqiu_duo[2]["请求方式"]
sql = ('SELECT * FROM pc_risk_limit')
maintenance_margin = db_link.get_one(sql) # 查询维持保证金率第一条数据
maintenance = maintenance_margin['maintenance_margin_rate'] # 取出维持保证金率
for i in token_test['token']:
print("-----------------------------------")
type_c = token_test['contract_type']
if type_c[0] == 1: # 判断是否全仓还是逐仓
contract_type = {"contract_type": '2'} # 是全仓换成逐仓
contract = requests_single(url='https://t01-mapi.deepcoin.pro/pc/set-contract-type',
requersts_type='post', paramt=contract_type, headers=i) # 切换仓位接口
contract_list = contract.getJson()
sql_usdt_Balance = requests_single(url='https://t01-mapi.deepcoin.pro/pc/balance', requersts_type='get',
paramt='1111', headers=i) # 查看余额接口
usdt_Balance = sql_usdt_Balance.getJson()
totoal = usdt_Balance.get('retData').get('futures_usdt_balance')
print("查看总额度", totoal)
# 下单
api_json = requests_single(url=host_duo, requersts_type=qingqiu_duo1, paramt=pramnt1_dict_duo, headers=i)
plan_order_id = api_json.getJson()
order_Msg1 = plan_order_id.get('retMsg') # 取出订单id
plan_order1 = plan_order_id.get('retData').get('plan_order_id')
try:
self.assertEqual(order_Msg1, '委托下单成功', msg='委托下单失败')
except Exception as e:
print(e)
sql_plan_order_id_to = "SELECT * FROM `pc_order` WHERE order_id='%s'" % (plan_order1) # 根据订单id查询订单表
print(sql_plan_order_id_to)
plan_order_to = db_link.get_one(sql_plan_order_id_to)
print('查询订单', plan_order_to)
'''
计算execl和落库的数据是否一致
'''
amount = float(pramnt1_dict_duo['quantity']) * float(pramnt1_dict_duo['price']) / float(
pramnt1_dict_duo['lever']) # 计算起始保证金
print('execl计算起始保证金', amount)
self.assertEqual(pramnt1_dict_duo['price'], slice_Character.split_to(plan_order_to['price']),
msg='参数1下单价格跟数据库价格不一致')
self.assertEqual(pramnt1_dict_duo['lever'], str(plan_order_to['lever']).rstrip('0').strip('.'),
msg='下单杠杆跟数据库价格不一致')
self.assertEqual(int(pramnt1_dict_duo['bs_flag']), plan_order_to['bs_flag'], msg='下单方向跟数据库价格不一致')
self.assertEqual(int(pramnt1_dict_duo['order_type']), plan_order_to['order_type'],
msg='下单订单类型跟数据库价格不一致')
self.assertEqual(round(amount, 4), float(plan_order_to['amount']), msg='保证金不相等')
self.assertEqual(round(amount, 4), float(plan_order_to['amount']), msg='保证金不相等')
symbol = "SELECT * FROM `pc_contract` WHERE symbol='BTC/USDT'" # 计算预收开仓手续费，取taker来计算的
symbol_BTC = db_link.get_one(symbol)
taker_fee_ratio_1 = plan_order_to['quantity'] * plan_order_to['price'] * symbol_BTC[
'taker_fee_ratio'] # 取出taken手续费计算开仓保证金.开仓价格*数量*起始保证金率
try:
# 判断开仓手续费是否相等
self.assertEqual(taker_fee_ratio_1, plan_order_to['open_fee'])
# 判断平仓手续费是否相等
self.assertEqual(taker_fee_ratio_1, plan_order_to['close_fee'])
# 判断杠杆是否相等
self.assertEqual(taker_fee_ratio_1['lever'], plan_order_to['lever'])
except Exception as e:
print(e)
# 下单第二组数据
print('***********************************************************************************')
time.sleep(10)
api_json_2 = requests_single(url=host_duo2, requersts_type=qingqiu2_duo, paramt=pramnt2_dict_duo,
headers=i)
plan_order_id_2 = api_json_2.getJson()
order_Msg_2 = plan_order_id_2.get('retMsg') # 取出订单id
plan_order_2 = plan_order_id_2.get('retData').get('plan_order_id')
try:
self.assertEqual(order_Msg_2, '委托下单成功', msg='委托下单失败')
except Exception as e:
print(e)
sql_plan_order_id_to_2 = "SELECT * FROM `pc_order` WHERE order_id='%s'" % (plan_order_2) # 根据订单id查询订单表
print(sql_plan_order_id_to_2)
plan_order_to_2 = db_link.get_one(sql_plan_order_id_to_2)
print('查询订单', plan_order_to_2)
'''
计算execl和落库的数据是否一致
'''
amount_3 = float(pramnt2_dict_duo['quantity']) * float(pramnt2_dict_duo['price']) / float(
pramnt2_dict_duo['lever']) # 计算起始保证金
print('execl计算起始保证金', amount_3)
print(type(plan_order_to_2['price']))
self.assertEqual(pramnt2_dict_duo['price'], str(plan_order_to_2['price']).rstrip('0').strip('.'),
msg='参数1下单价格跟数据库价格不一致')
self.assertEqual(pramnt2_dict_duo['lever'], str(plan_order_to_2['lever']).rstrip('0').strip('.'),
msg='下单杠杆跟数据库价格不一致')
self.assertEqual(int(pramnt2_dict_duo['bs_flag']), plan_order_to_2['bs_flag'], msg='下单方向跟数据库价格不一致')
self.assertEqual(int(pramnt2_dict_duo['order_type']), plan_order_to_2['order_type'],
msg='下单订单类型跟数据库价格不一致')
self.assertEqual(round(amount_3, 4), float(plan_order_to_2['amount']), msg='保证金不相等')
print('execl计算起始保证金', amount_3)
taker_fee_ratio_2 = plan_order_to_2['quantity'] * plan_order_to_2['price'] * symbol_BTC[
'taker_fee_ratio'] # 取出taken手续费计算开仓保证金.开仓价格*数量*起始保证金率
# 判断开仓手续费是否相等
self.assertEqual(taker_fee_ratio_2, plan_order_to_2['open_fee'])
# 判断平仓手续费是否相等
self.assertEqual(taker_fee_ratio_2, plan_order_to_2['close_fee'])
# 判断杠杆是否相等
self.assertEqual(pramnt2_dict_duo['lever'], slice_Character.split_to(plan_order_to_2['lever']))
time.sleep(2)
#查询剩余持仓数量
print('----------------------------------------------------------------------------------------------')
paramt='type:1'
api_json4 = requests_single(url='https://t01-mapi.deepcoin.pro/pc/order-list', requersts_type='post', paramt=paramt, headers=i)
plan_order_id4 = api_json4.getJson()
print(api_json4.url)
#['quantity']
quantity_order=plan_order_id4.get('retData')['list'][0]['quantity']
print(quantity_order)
trade_quantity_order = plan_order_id4.get('retData')['list'][0]['trade_quantity']
try:
totoal_quantity=float(quantity_order)-float(trade_quantity_order)
print('剩余持仓量')
self.assertEqual(slice_Character.split_to(quantity_order),slice_Character.split_to(trade_quantity_order),'用户还有未成交的委托订单')
except Exception as e:
print(e)
#第三组数据
print('***********************************************************************************')
time.sleep(10)
api_json_3 = requests_single(url=host_duo3, requersts_type=qingqiu3_duo, paramt=pramnt3_dict_duo,headers=i)
plan_order_id_3 = api_json_3.getJson()
order_Msg_3= plan_order_id_3.get('retMsg') # 取出订单id
plan_order_3= plan_order_id_3.get('retData').get('plan_order_id')
try:
self.assertEqual(order_Msg_3, '委托下单成功', msg='委托下单失败')
except Exception as e:
print(e)
sql_plan_order_id_to_3= "SELECT * FROM `pc_order` WHERE order_id='%s'" % (plan_order_3) # 根据订单id查询订单表
print(sql_plan_order_id_to_3)
plan_order_to_3 = db_link.get_one(sql_plan_order_id_to_3)
print('查询订单', plan_order_to_3)
'''
计算execl和落库的数据是否一致
'''
amount_4 = float(pramnt3_dict_duo['quantity']) * float(pramnt3_dict_duo['price']) / float(
pramnt3_dict_duo['lever']) # 计算起始保证金
print('execl计算起始保证金', amount_4)
print(type(plan_order_to_3['price']))
self.assertEqual(pramnt3_dict_duo['price'], str(plan_order_to_3['price']).rstrip('0').strip('.'),
msg='参数1下单价格跟数据库价格不一致')
self.assertEqual(pramnt3_dict_duo['lever'], str(plan_order_to_3['lever']).rstrip('0').strip('.'),
msg='下单杠杆跟数据库价格不一致')
self.assertEqual(int(pramnt3_dict_duo['bs_flag']), plan_order_to_3['bs_flag'], msg='下单方向跟数据库价格不一致')
self.assertEqual(int(pramnt3_dict_duo['order_type']), plan_order_to_3['order_type'],
msg='下单订单类型跟数据库价格不一致')
taker_fee_ratio_3 = plan_order_to_3['quantity'] * plan_order_to_3['price'] * symbol_BTC[
'taker_fee_ratio'] # 取出taken手续费计算开仓保证金.开仓价格*数量*起始保证金率
# 判断开仓手续费是否相等
self.assertEqual(taker_fee_ratio_3, plan_order_to_3['open_fee'])
# 判断平仓手续费是否相等
self.assertEqual(taker_fee_ratio_3, plan_order_to_3['close_fee'])
# 判断杠杆是否相等
self.assertEqual(pramnt3_dict_duo['lever'], slice_Character.split_rstrip(plan_order_to_3['lever']))
time.sleep(2)
'''
计算余额
'''
Balance = float((amount + amount_3+amount_4)) + float((taker_fee_ratio_1 + taker_fee_ratio_2+taker_fee_ratio_3) * 2)
print("下单金额", Balance)
# 查询余额
sql_usdt_Balance = requests_single(url='https://t01-mapi.deepcoin.pro/pc/balance', requersts_type='get',
paramt='1111', headers=i)
usdt_Balance = sql_usdt_Balance.getJson()
keyong = usdt_Balance.get('retData').get('futures_usdt_balance')
print('剩余余额', keyong)
print(totoal )
shengyu = float(totoal) - float(keyong)
print(float(totoal.replace(",", "")) - float(keyong.replace(",", "")))
print("正确扣减的金额", shengyu)
def test_create(self, data):
test = Test_Login(rise)
token_test = test.test_log()
'''
计算强评价
维持保证金
注意：取参数时，需要查看execl是否有多余的空格
:param data:
:return:
'''
cancel_order_id = data['order_id(订单id)']
paramt_type = data['期望请求方式']
# 1、市场价买涨算强平价格计算
# 2、多仓强平价格 = 开仓价格 * (1 - 起始保证金率 + 维持保证金率)
# 查询维持保证金率
sql = ('SELECT * FROM pc_risk_limit')
maintenance_margin = db_link.get_one(sql) # 查询维持保证金率第一条数据
maintenance = float(
maintenance_margin['maintenance_margin_rate']) # 取出维持保证金率
# #起始保证金率(1 - 1 / lever-维持保证金率)
# Strong_parity = price * (1 - 1 / lever - maintenance)
# print('强平价', Strong_parity)
paramt = {'order_id': cancel_order_id} # 拼接参数
print(paramt)
for i in token_test['token']: # 循环里面token_test的值
sql_usdt_Balance = requests_single(
url='https://t01-mapi.deepcoin.pro/pc/balance',
requersts_type='get',
paramt=paramt,
headers=i)
usdt_Balance = sql_usdt_Balance.getJson()
totoal = usdt_Balance.get('retData').get('futures_usdt_balance')
print(i)
head = {
"Content-Type": "application/x-www-form-urlencoded",
"token": i
} # 传token
api = requests_single(url=data['url'],
requersts_type=data['期望请求方式'],
paramt=paramt,
headers=i)
api_json = api.getJson() # 取返回joson值里面的值
retMsg = api_json.get('retMsg')
try:
self.assertEqual(retMsg, '委托下单成功', msg='下单失败')
except Exception as e:
print(e)
plan_order_id1 = api_json.get('retData').get(
'plan_order_id') # 取出订单id
sql_plan_order_id = "SELECT * FROM `pc_order` WHERE order_id='%s'" % (
plan_order_id1) # 根据订单id查询订单表
print(sql_plan_order_id)
plan_order = db_link.get_one(sql_plan_order_id)
print('查询订单', plan_order)
'''
