def test_01(self):
"""
限价多单1单，限价空单1单，完全成交，验证合约状态、用户余额
"""
logger.info("用例编号：40-1---限价多单N单，限价空单1单，完全成交，验证合约状态、用户余额")
range_num = 100
deal_num = 100000000
buy_num = 1000*100000000
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id)
now_stock_price = stock_price_dict["stockPrice"]
deal_price = int(int(now_stock_price) * 0.95)
# 下N个多单、空单，完全成交
for i in range(range_num):
buy_resp = self.session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=deal_price,order_num=deal_num
))
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：多单--返回信息：{3}".format(
self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json()
))
# time.sleep(0.2)
# time.sleep(1)
sell_resp = self.sell_session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=deal_price,order_num=buy_num
))
sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：空单--返回信息：{3}".format(
self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json()
))
# time.sleep(10)
# 查询当前持仓中买卖方持仓数量、保证金、开仓均价
after_buy_position_dict = query_account_position_get(user=self.buyer, session=self.session,
sync_key=sell_sync_id)
after_sell_position_dict = query_account_position_get(user=self.seller, session=self.sell_session,
sync_key=sell_sync_id)
after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"]
after_buy_sdaCount = after_buy_position_dict["sdaCount"]
after_buy_currencyBalancePosition = after_buy_position_dict["currencyBalancePosition"]
after_sell_sdaAveragePrice = after_sell_position_dict["sdaAveragePrice"]
after_sell_sdaCount = after_sell_position_dict["sdaCount"]
after_sell_currencyBalancePosition = after_sell_position_dict["currencyBalancePosition"]
# 计算保证金
# buy_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# 检验持仓均价，持仓量，保证金
price_flag = assert_one(int(deal_price), int(after_buy_sdaAveragePrice))
num_flag = assert_one(int(deal_num * range_num), int(after_buy_sdaCount))
# after_buy_flag = assert_one(buy_currency_balance, int(after_buy_currencyBalancePosition))
after_sell_flag = assert_list([int(deal_price), int(deal_num * range_num)], [int(after_sell_sdaAveragePrice), int(after_sell_sdaCount)])
self.assertListEqual([True, True, True], [price_flag, num_flag,after_sell_flag])
def test_01(self):
"""
多单1单，空单1单，多单完全成交，空单部分成交，验证合约状态、用户余额
"""
logger.info("用例编号：41-1---限价多单1单，限价空单1单，多单完全成交，空单部分成交，验证合约状态、用户余额")
deal_num = 100000000
sell_num = 200000000
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id)
now_stock_price = stock_price_dict["stockPrice"]
stock_unit = int(stock_price_dict["tradeUnit"])
deal_price = int(int(now_stock_price) * 0.95)
# 下一单多单、空单，完全成交
buy_resp = self.session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=deal_price, order_num=deal_num
))
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：多单--返回信息：{3}".format(
self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json()
))
# time.sleep(2)
sell_resp = self.sell_session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=deal_price, order_num=sell_num
))
sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：空单--返回信息：{3}".format(
self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json()
))
sell_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=sell_resp.text)
# time.sleep(4)
# 查询当前持仓中买卖方持仓数量、保证金、开仓均价
after_buy_position_dict = query_account_position_get(user=self.buyer, session=self.session, sync_key=sync_id)
after_sell_position_dict = query_account_position_get(user=self.seller, session=self.sell_session,
sync_key=sync_id)
after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"]
after_buy_sdaCount = after_buy_position_dict["sdaCount"]
after_buy_currencyBalancePosition = int(after_buy_position_dict["currencyBalancePosition"])
after_sell_sdaAveragePrice = after_sell_position_dict["sdaAveragePrice"]
after_sell_sdaCount = after_sell_position_dict["sdaCount"]
after_sell_currencyBalancePosition = after_sell_position_dict["currencyBalancePosition"]
# 计算保证金
buy_employ_balance = employBalance(price=deal_price, count=deal_num, unit=stock_unit, lever=1)
print("buy_employ_balance", buy_employ_balance)
print("after_buy")
# 检验持仓均价，持仓量，保证金，
price_flag = assert_one(int(deal_price), int(after_buy_sdaAveragePrice))
num_flag = assert_one(int(deal_num), int(after_buy_sdaCount))
after_buy_flag = assert_one(buy_employ_balance, after_buy_currencyBalancePosition)
after_sell_flag = assert_list([int(deal_price), int(deal_num)], [int(after_sell_sdaAveragePrice), int(after_sell_sdaCount)])
self.assertListEqual([True, True, True, True], [after_buy_flag, price_flag, num_flag,after_sell_flag])
def test_02(self):
"""
验证股价波动后持仓价值变化
:return:
"""
logger.info("用例编号：202-2，验证股价波动后持仓价值变化")
# 修改股价并重新计算用户持仓价值
after_stock_price = 22
set_stock_price(stock_price=after_stock_price)
market_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
print("now stock price", market_dict["stockPrice"])
print("tradeUnit", market_dict["tradeUnit"])
positions_dict = query_account_position_get(user=self.buyer,
session=self.session,
sync_key=self.sync_key)
# print(positions_dict)
print("sdaValuation", positions_dict["sdaValuation"])
print("sdaOpeningValuation", positions_dict["sdaOpeningValuation"])
before_positions_value = positions_dict["sdaValuation"]
# 股价波动
after_stock_price = 22
set_stock_price(stock_price=after_stock_price)
# 股价波动后查询用户持仓价值
time.sleep(2)
after_positions_dict = query_account_position_get(
user=self.buyer, session=self.session, sync_key=self.sync_key)
print("sdaValuation", after_positions_dict["sdaValuation"])
print("sdaOpeningValuation",
after_positions_dict["sdaOpeningValuation"])
after_positions_value = positions_value(
stock_price=after_stock_price * 100000000,
hold_num=self.deal_num,
trade_unit=int(market_dict["tradeUnit"]))
after_open_positions_value = open_positions_value(
hold_price=self.deal_price,
hold_num=self.deal_num,
trade_unit=int(market_dict["tradeUnit"]))
positions_flag = assert_one(int(after_positions_value),
int(after_positions_dict["sdaValuation"]))
open_positions_value_flag = assert_one(
int(after_open_positions_value),
int(after_positions_dict["sdaOpeningValuation"]))
self.assertListEqual([True, True],
[positions_flag, open_positions_value_flag])
def test_01(self):
"""
持仓后验证持仓价值是否返回
:return:
"""
logger.info("用例编号：202-1，验证持仓价值和开仓价值计算")
market_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
print("now stock price", market_dict["stockPrice"])
print("tradeUnit", market_dict["tradeUnit"])
positions_dict = query_account_position_get(user=self.buyer,
session=self.session,
sync_key=self.sync_key)
# print(positions_dict)
print("sdaValuation", positions_dict["sdaValuation"])
print("sdaOpeningValuation", positions_dict["sdaOpeningValuation"])
buy_open_positions_value = open_positions_value(
hold_price=self.deal_price,
hold_num=self.deal_num,
trade_unit=int(market_dict["tradeUnit"]))
print("buy_open_positions_value", buy_open_positions_value)
buy_positions_value = positions_value(
stock_price=int(market_dict["stockPrice"]),
hold_num=self.deal_num,
trade_unit=int(market_dict["tradeUnit"]))
print("buy_positions_value", buy_positions_value)
flag = assert_list([
int(positions_dict["sdaValuation"]),
int(positions_dict["sdaOpeningValuation"])
], [int(buy_positions_value),
int(buy_open_positions_value)])
self.assertEqual(flag, True)
def test_01(self, lever):
"""
参数化测试不同杠杆倍数成交，先限价多单，后市价空单
:return:
"""
logger.info(
"用例编号：112-1---参数化测试不同杠杆倍数,5,10,20,50,100,成交，先限价多单，后市价空单，完全成交，验证余额")
deal_num = 100000000
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
now_stock_price = stock_price_dict["stockPrice"]
deal_price = int(int(now_stock_price) * 0.95)
# 下一单多单、空单，完全成交
buy_resp = self.session.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=多单,
order_price_type=限价,
lever=lever,
order_price=deal_price,
order_num=deal_num))
buy_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=buy_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：多单--返回信息：{3}".format(
self.buyer, sda_order_create_url, buy_resp.status_code,
buy_resp.json()))
# time.sleep(3)
sell_resp = self.sell_session.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=空单,
order_price_type=市价,
order_price=deal_price,
order_num=deal_num))
sell_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=sell_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：空单--返回信息：{3}".format(
self.seller, sda_order_create_url, sell_resp.status_code,
sell_resp.json()))
time.sleep(4)
# 查询当前持仓中买卖方持仓数量、保证金、开仓均价
after_buy_position_dict = query_account_position_get(
user=self.buyer, session=self.session)
after_sell_position_dict = query_account_position_get(
user=self.seller, session=self.sell_session)
after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"]
after_buy_sdaCount = after_buy_position_dict["sdaCount"]
after_buy_currencyBalancePosition = after_buy_position_dict[
"currencyBalancePosition"]
after_sell_sdaAveragePrice = after_sell_position_dict[
"sdaAveragePrice"]
after_sell_sdaCount = after_sell_position_dict["sdaCount"]
after_sell_currencyBalancePosition = after_sell_position_dict[
"currencyBalancePosition"]
# 计算保证金
# buy_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# 检验持仓均价，持仓量，保证金
price_flag = assert_one(int(deal_price),
int(after_buy_sdaAveragePrice))
num_flag = assert_one(int(deal_num), int(after_buy_sdaCount))
# after_buy_flag = assert_one(buy_currency_balance, int(after_buy_currencyBalancePosition))
after_sell_flag = assert_list(
[int(deal_price), int(deal_num)],
[int(after_sell_sdaAveragePrice),
int(after_sell_sdaCount)])
self.assertListEqual([True, True, True],
[price_flag, num_flag, after_sell_flag])
def test_01(self):
"""
限价多单1单，杠杆5倍，限价空单1单，杠杆1倍，完全成交，验证合约状态、用户余额
"""
logger.info(
"用例编号：119-1---限价多单1单，杠杆50倍，限价空单1单，杠杆1倍，完全成交，验证保证金、开仓手续费、预估爆仓价")
deal_num = 10 * 100000000
lever = 50
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
now_stock_price = int(stock_price_dict["stockPrice"])
stock_unit = int(stock_price_dict["tradeUnit"])
deal_price = int(int(now_stock_price) * 0.95)
# deal_price = 18*100000000
before_buy_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id)
before_buy_balance = before_buy_dict["balance"]
# 下一单多单、空单，完全成交
buy_resp = self.session.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=多单,
order_price_type=限价,
lever=lever,
order_price=deal_price,
order_num=deal_num))
buy_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=buy_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：多单--返回信息：{3}".format(
self.buyer, sda_order_create_url, buy_resp.status_code,
buy_resp.json()))
# time.sleep(3)
sell_resp = self.sell_session.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=空单,
order_price_type=限价,
lever=lever,
order_price=deal_price,
order_num=deal_num))
sell_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=sell_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：空单--返回信息：{3}".format(
self.seller, sda_order_create_url, sell_resp.status_code,
sell_resp.json()))
# 计算仓位保证金
buy_employ_balance = employBalance(price=deal_price,
count=deal_num,
unit=stock_unit,
lever=lever)
print(buy_employ_balance)
# 计算开仓手续费
open_stock_cost = openStockCost(price=deal_price,
count=deal_num,
doMore=True,
unit=stock_unit,
stockPrice=now_stock_price)
# 计算未实现盈亏
buy_real_less = int(
unRealLoss(holdAvgPrice=deal_price,
count=deal_num,
unit=stock_unit,
doMore=True,
holdCharge=open_stock_cost,
stock_price=now_stock_price))
# 计算爆仓价
buy_crash_price = crashPrice(holdAvgPrice=deal_price,
holdCount=deal_num,
totalBalance=self.sda_balance -
open_stock_cost,
unit=stock_unit,
doMore=True)
time.sleep(0.1)
buy_position_get_dict = query_account_position_get(
user=self.buyer, session=self.session, sync_key=sell_sync_id)
buy_bust_price = int(buy_position_get_dict["sdaBustPrice"]) # 预估爆仓价
buy_balance_position = int(
buy_position_get_dict["currencyBalancePosition"]) # 仓位保证金
buy_unrealized_PNL = int(
buy_position_get_dict["unrealizedPNL"]) # 未实现盈亏
balance_flag = assert_one(buy_balance_position,
buy_employ_balance) # 检验保证金
bust_flag = assert_one(buy_bust_price, buy_crash_price) # 检验爆仓
pnl_flag = assert_one(buy_unrealized_PNL, buy_real_less) # 检验未实现盈亏
self.assertListEqual([True, True, True],
[bust_flag, pnl_flag, balance_flag])
def test_03(self, lever, lever_two):
"""
多单1单，空单1单，多单部分成交，空单完全成交，验证合约状态、用户余额
"""
logger.info("用例编号：114-3---限价多单1单，限价空单1单，多单部分成交，空单完全成交，验证合约状态、用户余额")
deal_num = 200000000
sell_num = 100000000
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
now_stock_price = stock_price_dict["stockPrice"]
deal_price = int(int(now_stock_price) * 0.95)
# 下一单多单、空单，完全成交
buy_resp = self.session.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=多单,
order_price_type=限价,
lever=lever,
order_price=deal_price,
order_num=deal_num))
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：多单--返回信息：{3}".format(
self.buyer, sda_order_create_url, buy_resp.status_code,
buy_resp.json()))
buy_order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
body=buy_resp.text)
# time.sleep(1)
sell_resp = self.sell_session.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=空单,
order_price_type=限价,
lever=lever_two,
order_price=deal_price,
order_num=sell_num))
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：空单--返回信息：{3}".format(
self.seller, sda_order_create_url, sell_resp.status_code,
sell_resp.json()))
sell_order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
body=sell_resp.text)
# time.sleep(1)
after_buy_balance = self.session.post(
url=base + sda_account_asset_detail_get_url,
data=get_sda_account_asset_detail_get_param())
after_sell_balance = self.sell_session.post(
url=base + sda_account_asset_detail_get_url,
data=get_sda_account_asset_detail_get_param())
after_buy_balance_value = JMESPathExtractor().extract(
query="OBJECT.PNLList[0].availableMargin",
body=after_buy_balance.text)
after_sell_balance_value = JMESPathExtractor().extract(
query="OBJECT.PNLList[0].availableMargin",
body=after_sell_balance.text)
after_buy_entrust_value = JMESPathExtractor().extract(
query="OBJECT.PNLList[0].entrustMargin",
body=after_buy_balance.text)
after_sell_entrust_value = JMESPathExtractor().extract(
query="OBJECT.PNLList[0].entrustMargin",
body=after_sell_balance.text)
# 查询当前持仓中买卖方持仓数量、保证金、开仓均价
time.sleep(4)
after_buy_position_dict = query_account_position_get(
user=self.buyer, session=self.session)
after_sell_position_dict = query_account_position_get(
user=self.seller, session=self.sell_session)
after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"]
after_buy_sdaCount = after_buy_position_dict["sdaCount"]
after_buy_currencyBalancePosition = after_buy_position_dict[
"currencyBalancePosition"]
after_sell_sdaAveragePrice = after_sell_position_dict[
"sdaAveragePrice"]
after_sell_sdaCount = after_sell_position_dict["sdaCount"]
after_sell_currencyBalancePosition = after_sell_position_dict[
"currencyBalancePosition"]
# 计算保证金
# buy_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# 检验持仓均价，持仓量，保证金
price_flag = assert_one(int(deal_price),
int(after_buy_sdaAveragePrice))
num_flag = assert_one(int(sell_num), int(after_buy_sdaCount))
# after_buy_flag = assert_one(buy_currency_balance, int(after_buy_currencyBalancePosition))
after_sell_flag = assert_list(
[int(deal_price), int(sell_num)],
[int(after_sell_sdaAveragePrice),
int(after_sell_sdaCount)])
self.assertListEqual([True, True, True],
[price_flag, num_flag, after_sell_flag])
def test_01(self):
"""
大数极限测试类
"""
logger.info("用例编号：110-1---大数极限测试类")
deal_num = 90000000000*100000000
lever = 100
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id)
now_stock_price = stock_price_dict["stockPrice"]
stock_unit = int(stock_price_dict["tradeUnit"])
deal_price = int(int(now_stock_price) * 1)
# deal_price = now_stock_price
print("stock price", now_stock_price)
before_buy_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id)
before_buy_balance = before_buy_dict["balance"]
# 下一单多单、空单，完全成交
buy_resp = self.session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=多单, order_price_type=限价, lever=lever, order_price=deal_price,order_num=deal_num
))
buy_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：多单--返回信息：{3}".format(
self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json()
))
# time.sleep(3)
sell_resp = self.sell_session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=空单, order_price_type=限价, lever=lever, order_price=deal_price,order_num=deal_num
))
sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：空单--返回信息：{3}".format(
self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json()
))
# time.sleep(5)
# 查询当前持仓中买卖方持仓数量、保证金、开仓均价
after_buy_position_dict = query_account_position_get(sync_key=sell_sync_id, user=self.buyer,
session=self.session)
after_sell_position_dict = query_account_position_get(sync_key=sell_sync_id, user=self.seller,
session=self.sell_session)
after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"]
after_buy_sdaCount = after_buy_position_dict["sdaCount"]
after_buy_currencyBalancePosition = after_buy_position_dict["currencyBalancePosition"]
after_sell_sdaAveragePrice = after_sell_position_dict["sdaAveragePrice"]
after_sell_sdaCount = after_sell_position_dict["sdaCount"]
after_sell_currencyBalancePosition = after_sell_position_dict["currencyBalancePosition"]
# 计算保证金
buy_currency_balance = employBalance(price=deal_price, count=deal_num, unit=stock_unit, lever=lever)
# 检验持仓均价，持仓量，保证金
balance_flag = assert_one(int(after_buy_currencyBalancePosition), int(buy_currency_balance))
self.assertTrue(balance_flag)
price_flag = assert_one(int(deal_price), int(after_buy_sdaAveragePrice))
num_flag = assert_one(int(deal_num), int(after_buy_sdaCount))
# after_buy_flag = assert_one(buy_currency_balance, int(after_buy_currencyBalancePosition))
after_sell_flag = assert_list([int(deal_price), int(deal_num)], [int(after_sell_sdaAveragePrice), int(after_sell_sdaCount)])
self.assertListEqual([True, True, True], [price_flag, num_flag,after_sell_flag])
def test_02(self):
"""
限价空单1单，50倍杠杆，限价多单1单，1倍杠杆，完全成交，验证合约状态、用户余额
"""
logger.info("用例编号：110-2---限价空单1单，50倍杠杆，限价多单1单，1倍杠杆，完全成交，验证合约状态、用户余额")
deal_num = 200000000
lever = 50
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id)
now_stock_price = stock_price_dict["stockPrice"]
deal_price = int(int(now_stock_price) * 0.95)
# 交易前查询用户余额
before_buy_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id)
before_buy_balance = before_buy_dict["balance"]
# 下一单多单、空单，完全成交
buy_resp = self.session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=空单, order_price_type=限价, lever=lever, order_price=deal_price,order_num=deal_num
))
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：空单--返回信息：{3}".format(
self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json()
))
# time.sleep(3)
sell_resp = self.sell_session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=deal_price, order_num=deal_num
))
sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text)
logger.info("用户：{0}--接口：{1}--状态：{2}--类型：多单--返回信息：{3}".format(
self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json()
))
# time.sleep(1)
# 查询当前持仓中买卖方持仓数量、保证金、开仓均价
after_buy_position_dict = query_account_position_get(sync_key=sell_sync_id, user=self.buyer,
session=self.session)
after_sell_position_dict = query_account_position_get(sync_key=sell_sync_id, user=self.seller,
session=self.sell_session)
after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"]
after_buy_sdaCount = after_buy_position_dict["sdaCount"]
after_buy_currencyBalancePosition = after_buy_position_dict["currencyBalancePosition"]
after_sell_sdaAveragePrice = after_sell_position_dict["sdaAveragePrice"]
after_sell_sdaCount = after_sell_position_dict["sdaCount"]
after_sell_currencyBalancePosition = after_sell_position_dict["currencyBalancePosition"]
# 计算保证金
buy_currency_balance = (deal_num * deal_price / 100000000) / lever
# sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# 检验持仓均价，持仓量，保证金
balance_flag = assert_one(int(after_buy_currencyBalancePosition), int(buy_currency_balance))
self.assertTrue(balance_flag)
price_flag = assert_one(int(deal_price), int(after_buy_sdaAveragePrice))
num_flag = assert_one(int(deal_num), int(after_buy_sdaCount))
# after_buy_flag = assert_one(buy_currency_balance, int(after_buy_currencyBalancePosition))
after_sell_flag = assert_list([int(deal_price), int(deal_num)], [int(after_sell_sdaAveragePrice),
int(after_sell_sdaCount)])
self.assertListEqual([True, True, True], [price_flag, num_flag,after_sell_flag])
