def test_01(self):
"""
多单持仓，平仓，53用户下多单与之成交。
"""
logger.info("用例编号：90-1---多单持仓，部分平仓，追加仓位，全平")
range_num = 10
price = 120*100000000
buy_num = 110*100000000
first_num = 10*100000000
add_first_num = 20*100000000
add_first_price = 110*100000000
# 平多单
time.sleep(1)
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=price, order_num=first_num
))
logger.info("接口：{0}----返回信息：{1}".format(sda_order_create_url, buy_resp.json()))
# 53用户下多单。
# time.sleep(1)
buy_53_resp = self.session_53.post(url=base+sda_order_create_url,data=get_sda_order_create_param(
sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=price, order_num=first_num
))
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url, buy_53_resp.json()))
# 第一次追仓
# time.sleep(2)
first_add_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=add_first_price, order_num=add_first_num
))
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url, first_add_buy_resp.json()))
# time.sleep(1)
# 54用户下空单
resp_54 = self.session_54.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=add_first_price, order_num=add_first_num
))
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url, resp_54.json()))
# time.sleep(3)
# 限价全平
time.sleep(1)
second_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=price, order_num=buy_num
))
second_buy_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=second_buy_resp.text)
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url, second_buy_resp.json()))
# 53用户下单成交
second_sell_resp = self.session_53.post(url=base+sda_order_create_url, data=get_sda_order_create_param(
sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=price, order_num=buy_num
))
second_sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=second_sell_resp.text)
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url, second_sell_resp.json()))
after_53_info_dict = account_info_sync(sync_id=second_sell_sync_id, user=self.user_53, session=self.session_53, sda_id=sda_id)
after_53_account_balance = after_53_info_dict["balance"]
# time.sleep(3)
after_info_dict = account_info_sync(sync_id=second_buy_sync_id, user=self.buyer, session=self.session, sda_id=sda_id)
after_account_balance = after_info_dict["balance"]
flag_51 = assert_one(int(after_account_balance), 10000239216002299)
self.assertTrue(flag_51)
def test_01(self):
"""
正常访问资金划转接口，验证接口状态、status、msg
"""
amount = 100000000
logger.info("用例编号：2-1---资金划转接口测试类，正常访问资金划转接口，验证接口状态、status、msg")
ConnectMysql(_type=mysql_type).update_balance_value(
user_mail=self.buyer,
currency_id=currency_id,
balance_value=90000000000)
# 转入前查询bb账户余额
before_bb_account_resp = self.session.post(
url=base + get_user_balance_servlet_url,
data=get_user_balance_servlet_param(user=self.buyer,
currency_id=currency_id))
before_currency_balance = JMESPathExtractor().extract(
query="OBJECT.balanceValue", body=before_bb_account_resp.text)
logger.info("用户：{0}---币ID：{1}---转入前余额：{2}".format(
self.buyer, currency_id, before_currency_balance))
# 转入前查询合约账户余额
info_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id)
before_account_balance = info_dict["balance"]
deposit_resp = self.session.post(url=base + sda_account_deposit_url,
data=get_sda_account_deposit_param(
sda_id=sda_id, amount=amount))
logger.info("用户：{0}---接口：{1}---状态：{2}---正常划转返回信息：{3}".format(
self.buyer, sda_account_deposit_url, deposit_resp.status_code,
deposit_resp.json()))
status = JMESPathExtractor().extract(query="STATUS",
body=deposit_resp.text)
msg = JMESPathExtractor().extract(query="MSG", body=deposit_resp.text)
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=deposit_resp.text)
print("msg:", type(msg))
time.sleep(2)
# 转入后查询合约账户余额
after_info_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id)
after_account_balance = after_info_dict["balance"]
# 转入后查询BB账户余额
# time.sleep(1)
after_bb_account_resp = self.session.post(
url=base + get_user_balance_servlet_url,
data=get_user_balance_servlet_param(self.buyer,
currency_id=currency_id))
after_currency_balance = JMESPathExtractor().extract(
query="OBJECT.balanceValue", body=after_bb_account_resp.text)
logger.info("用户：{0}--币ID：{1}--转入后余额：{2}".format(
self.buyer, currency_id, after_currency_balance))
# _object = JMESPathExtractor().extract(query="OBJECT", body=deposit_resp.text)
print("before account balance", before_account_balance)
print("amount:", amount)
print("after account balance:", after_account_balance)
flag = assert_list([200, "0"], [deposit_resp.status_code, status])
flag_1 = assert_one(
int(before_currency_balance) - int(amount),
int(after_currency_balance))
flag_2 = assert_one(
int(before_account_balance) + int(amount),
int(after_account_balance))
self.assertListEqual([True, True, True], [flag, flag_1, flag_2])
def test_01(self):
"""
限价多单持仓成功，下限价多单委托，验证余额，委托状态
"""
logger.info("用例编号：116-1---多单持仓成功，下限价多单50倍杠杆委托，下限价空单成交，验证余额，委托状态")
range_num = 5
# price = 100000000
buy_num = 100000000
sell_num = buy_num * range_num
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)
# 下委托前查询可用余额
info_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id,
price=1000000000)
before_balance = info_dict["balance"]
for i in range(range_num):
# 下限价委托
buy_order_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=buy_num,
))
# time.sleep(0.1)
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url,
buy_order_resp.json()))
sell_order_resp = self.session_54.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=sell_num))
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=sell_order_resp.text)
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url,
sell_order_resp.json()))
# 下委托后查询可用余额
# time.sleep(2)
after_info_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id,
price=1000000000)
after_balance = after_info_dict["balance"]
flag = assert_one(
int(before_balance),
int(after_balance) +
int(sell_num * deal_price / lever / 100000000))
self.assertTrue(flag)
def test_02(self):
"""
空单持仓中，限价全平，多个对应委托，成交其中部分委托，验证委托状态、用户余额、手续费
"""
logger.info("用例编号：66-2---空单持仓中，限价全平，多个对应委托，成交其中部分委托，验证委托状态、用户余额、手续费")
range_num = 10
price = 20 * 100000000
buy_num = 10 * 100000000
sell_num = 2 * 100000000
# 平空单
time.sleep(0.5)
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=price,
order_num=buy_num))
sell_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=sell_resp.text)
logger.info("接口：{0}----返回信息：{1}".format(sda_order_create_url,
sell_resp.json()))
# time.sleep(2)
sync_53_id = None
for i in range(range_num):
# 53用户下多单。
# time.sleep(1)
buy_53_resp = self.session_53.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=空单,
order_price_type=限价,
order_price=price,
order_num=sell_num))
sync_53_id = JMESPathExtractor().extract(query="syncLockKey",
body=buy_53_resp.text)
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url,
buy_53_resp.json()))
# time.sleep(2)
after_53_info_dict = account_info_sync(sync_id=sync_53_id,
user=self.user_53,
session=self.session_53,
sda_id=sda_id)
after_53_account_balance = after_53_info_dict["balance"]
after_info_dict = account_info_sync(sync_id=sell_sync_id,
user=self.seller,
session=self.sell_session,
sda_id=sda_id)
after_account_balance = after_info_dict["balance"]
flag_51 = assert_one(int(after_account_balance), 9999997802034237)
flag_53 = assert_one(
self.sda_balance - int(price * sell_num * 10 / 100000000),
int(after_53_account_balance))
self.assertListEqual([True, True], [flag_51, flag_53])
def test_01(self):
"""
多单，验证合约状态、余额。
"""
logger.info("用例编号：20-1---限价多单，验证合约、用户余额。")
deal_price = 100000000
deal_num = 100000000
# 更新此合约ID下的所有合约状态为2
ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id)
ConnectRedis(_type=redis_type,
db=4).sda_clear_user_balance(user_id=self.user_id,
keys=sda_id)
ConnectMysql(_type=mysql_type).sda_update_user_balance(
user_id=self.user_id, sda_id=sda_id, sda_balance=990000000000)
# 查询当前合约的unit
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"])
# print("now stock price", now_stock_price)
# 下单前查询两个用户的余额
account_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id)
buy_balance = account_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_type.多单,
order_price_type=order_type.限价,
order_price=deal_price,
order_num=deal_num))
buy_order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
body=buy_resp.text)
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()))
# 计算委托价值
stock_value = int(
stockValue(price=deal_price, count=deal_num, unit=stock_unit))
print("stock_value", stock_value)
# 查询当前委托
order_get_open_resp = self.session.post(
url=base + sda_order_get_open_url,
data=get_sda_order_get_open_param(sda_id=sda_id))
get_order_id = JMESPathExtractor().extract(
query="LIST[0].orderId", body=order_get_open_resp.text)
order_num = JMESPathExtractor().extract(query="LIST[0].orderQuantity",
body=order_get_open_resp.text)
order_price = JMESPathExtractor().extract(
query="LIST[0].orderPrice", body=order_get_open_resp.text)
total_price = int(JMESPathExtractor().extract(
query="LIST[0].totalPrice", body=order_get_open_resp.text))
order_flag = assert_list(
[buy_order_id, deal_price, deal_num],
[get_order_id, int(order_price),
int(order_num)])
total_price_flag = assert_one(stock_value, total_price)
self.assertTrue(total_price_flag)
self.assertTrue(order_flag)
after_account_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id)
after_account_balance = after_account_dict["balance"]
flag = assert_one(int(buy_balance),
int(after_account_balance) + deal_num)
self.assertTrue(flag)
def test_02(self):
"""
限价空单持仓成功，下空单委托
"""
logger.info("用例编号：116-2---空单持仓成功，下限价多单,下市价空单委托100倍杠杆，完全成交，验证余额")
range_num = 5
sell_num = 1000000000
buy_num = sell_num
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"]
price = int(int(now_stock_price) * 0.95)
# 下委托前查询可用余额
info_dict = account_info(user=self.seller,
session=self.sell_session,
sda_id=sda_id,
price=1000000000)
before_balance = info_dict["balance"]
buy_order_resp = self.session_53.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=多单,
order_price_type=限价,
order_price=price,
order_num=buy_num))
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url,
buy_order_resp.json()))
sell_order_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_num=sell_num))
# time.sleep(0.1)
logger.info("接口：{0}----返回信息：{1}".format(sda_order_create_url,
sell_order_resp.json()))
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=sell_order_resp.text)
# 下委托后查询可用余额
# time.sleep(3)
after_info_dict = account_info_sync(sync_id=sync_id,
user=self.seller,
session=self.sell_session,
sda_id=sda_id,
price=1000000000)
after_balance = after_info_dict["balance"]
flag = assert_one(
int(before_balance),
int(after_balance) + buy_num * price / lever / 100000000)
self.assertTrue(flag)
def test_02(self):
"""
空单，验证合约状态、余额。
"""
logger.info("用例编号：20-2---限价空单，验证合约状态、余额。")
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
now_stock_price = stock_price_dict["stockPrice"]
price = int(int(now_stock_price) * 0.95)
deal_num = 100000000
# 更新此合约ID下的所有合约状态为3
ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id)
ConnectRedis(_type=redis_type,
db=4).sda_clear_user_balance(user_id=self.user_id,
keys=sda_id)
ConnectMysql(_type=mysql_type).sda_update_user_balance(
user_id=self.user_id, sda_id=sda_id, sda_balance=990000000000)
# 下单前查询两个用户的余额
account_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id)
buy_balance = account_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_type.空单,
order_price_type=order_type.限价,
order_price=price,
order_num=deal_num))
buy_order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
body=buy_resp.text)
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()))
# 查询当前委托
order_get_open_resp = self.session.post(
url=base + sda_order_get_open_url,
data=get_sda_order_get_open_param(sda_id=sda_id,
order_id=buy_order_id))
get_order_id = JMESPathExtractor().extract(
query="LIST[0].orderId", body=order_get_open_resp.text)
order_num = JMESPathExtractor().extract(query="LIST[0].orderQuantity",
body=order_get_open_resp.text)
order_price = JMESPathExtractor().extract(
query="LIST[0].orderPrice", body=order_get_open_resp.text)
# 查询用户余额，然后判断下单前后的用户余额
after_account_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id)
after_account_balance = after_account_dict["balance"]
flag = assert_one(
int(buy_balance),
int(after_account_balance) + deal_num * price / 100000000)
self.assertTrue(flag)
def test_01(self):
"""
限价多单委托，正常下单。
"""
logger.info("用例编号：6-1---限价多单委托，正常下单。")
price = 100000000
num = 100000000
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"])
ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id)
ConnectRedis(_type=redis_type,
db=4).sda_clear_user_balance(user_id=self.user_id,
keys=sda_id)
ConnectMysql(_type=mysql_type).sda_update_user_balance(
user_id=self.user_id, sda_id=sda_id, sda_balance=990000000000)
# 查询可用余额
info_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id,
price=1000000000)
before_balance = info_dict["balance"]
# 下限价委托
order_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=price,
order_num=num,
))
logger.info("下单：{}".format(order_resp.text))
msg = JMESPathExtractor().extract(query="MSG", body=order_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=order_resp.text)
order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
body=order_resp.text)
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=order_resp.text)
# 查询当前委托
# time.sleep(1)
get_open_dict = query_order_get_open(user=self.buyer,
session=self.session,
order_id=order_id)
order_quantity = get_open_dict["orderQuantity"] # 委托数量
order_price = get_open_dict["orderPrice"] # 委托价格
order_status = get_open_dict["orderStatus"] # 委托状态
# 查询下委托后的可用余额
time.sleep(5)
after_info_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id,
price=1000000000)
after_balance = after_info_dict["balance"]
employ_balance = employBalance(price=price,
count=num,
unit=stock_unit,
lever=1)
flag_one = assert_one(int(before_balance),
int(after_balance) + int(employ_balance))
flag_two = assert_list(
[int(order_quantity),
int(order_price), order_status], [num, price, "0"])
flag_three = assert_list([200, "SUCCESS", "0"],
[order_resp.status_code, msg, status])
self.assertListEqual([True, True, True],
[flag_one, flag_two, flag_three])
def test_02(self):
"""
限价空单，下单数量小于可用余额数量，验证下单状态。
"""
logger.info("用例编号：22-2---限价空单，下单数量小于可用余额数量，验证下单状态。")
sda_balance = 9000000000000
num = sda_balance + 100000000
ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id)
ConnectRedis(_type=redis_type,
db=4).sda_clear_user_balance(user_id=self.user_id,
keys=sda_id)
ConnectMysql(_type=mysql_type).sda_update_user_balance(
user_id=self.user_id, sda_id=sda_id, sda_balance=sda_balance)
# 查询当前股价
stock_price_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
now_stock_price = stock_price_dict["stockPrice"]
price = int(int(now_stock_price) * 0.95)
# 查询可用余额
info_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id)
before_balance = info_dict["balance"]
# 下限价委托
order_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=price,
order_num=num,
))
msg = JMESPathExtractor().extract(query="MSG", body=order_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=order_resp.text)
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=order_resp.text)
# order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=order_resp.text)
# 查询当前委托
# get_open_dict = query_order_get_open(user=self.buyer, session=self.session, order_id=order_id)
# order_quantity = get_open_dict["orderQuantity"] # 委托数量
# order_price = get_open_dict["orderPrice"] # 委托价格
# order_status = get_open_dict["orderStatus"] # 委托状态
# 查询下委托后的可用余额
after_info_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id)
after_balance = after_info_dict["balance"]
flag_one = assert_one(int(before_balance), int(after_balance))
flag_three = assert_list([200, "该订单将会触发您所持仓位的强平", "1"],
[order_resp.status_code, msg, status])
self.assertListEqual([True, True], [flag_one, flag_three])
def test_03(self):
"""
限价空单1单，市价多单1单，多单部分成交，空单完全成交，验证合约状态、用户余额
"""
logger.info("用例编号：45-3---限价空单1单，市价多单1单，多单部分成交，空单完全成交，验证合约状态、用户余额")
sell_num = 100000000
buy_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"]
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=price,
order_num=sell_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=price,
order_num=buy_num))
sell_order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
body=sell_resp.text)
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(2)
info_dict = account_info_sync(sync_id=sync_id,
user=self.seller,
session=self.sell_session,
sda_id=sda_id)
after_sell_balance = info_dict["balance"]
buy_info_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id)
after_buy_balance = buy_info_dict["balance"]
# 计算保证金
# buy_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price)
# 检验持仓均价，持仓量，保证金
sell_flag = assert_one(
int(self.sda_balance - sell_num * price / 100000000),
int(after_sell_balance))
buy_flag = assert_one(
int(self.sda_balance - sell_num * price / 100000000),
int(after_buy_balance))
self.assertListEqual([True, True], [sell_flag, buy_flag])
def test_01(self):
"""
连续下N个多单，连续撤单，检查委托状态、用户余额
"""
logger.info("用例编号：31-1---连续下N个多单，连续撤单，检查委托状态、用户余额")
ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order(
user_id=self.user_id, contract_id=sda_id, status=2)
ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id)
ConnectRedis(_type=redis_type,
db=4).sda_clear_user_balance(user_id=self.user_id,
keys=sda_id)
ConnectMysql(_type=mysql_type).sda_update_user_balance(
user_id=self.user_id, sda_id=sda_id, sda_balance=99000000000000)
deal_price = 100000000
deal_num = 100000000
# 下委托前查询可用余额
info_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id,
price=1000000000)
before_balance = info_dict["balance"]
cancel_num = None
sync_id = None
for i in range(1000):
# 下多单限价
cancel_num = i
buy_resp = self.session.post(url=base + sda_order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=order_type.多单,
order_price_type=order_type.限价,
order_price=deal_price,
order_num=deal_num))
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=buy_resp.text)
buy_order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
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(1)
cancel_resp = self.session.post(url=base + sda_order_cancel_url,
data=get_sda_order_cancel_param(
sda_id=sda_id,
order_id=buy_order_id,
order_type=多单))
logger.info("撤单接口状态：{0}---返回信息：{1}".format(cancel_resp.status_code,
cancel_resp.json()))
logger.info("撤单次数：{}".format(i))
# time.sleep(1)
# 下委托后查询可用余额
time.sleep(2)
after_info_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id,
price=1000000000)
after_balance = after_info_dict["balance"]
logger.info("撤单次数：{}".format(cancel_num))
available_margin_flag = assert_one(int(before_balance),
int(after_balance))
self.assertTrue(available_margin_flag)