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) '''