def test_04(self):
"""
空单持仓中，部分限价平仓，验证持仓余额，平仓委托中状态，用户余额，手续费
:return:
"""
logger.info(
"用例编号：51-4---空单持仓中，部分限价平仓，市价空单与平空成交，验证持仓余额，平仓委托中状态，用户余额，手续费")
range_num = 10
price = 120 * 100000000
buy_num = 50 * 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()))
# 53用户下多单。
# time.sleep(2)
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=buy_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(3)
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), 9999386552015461)
flag_53 = assert_one(
self.sda_balance - int(price * buy_num / 100000000),
int(after_53_account_balance))
self.assertListEqual([True, True], [flag_51, flag_53])
def test_04(self):
"""
市价空单，可用余额小于下单数量，验证下单是否成功
"""
logger.info("用例编号：20-4---市价空单，可用余额小于下单数量，验证下单是否成功")
sda_balance = 9000000000000
price = 100000000
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)
# 查询可用余额
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_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"] # 委托状态
# 查询下委托后的可用余额
# time.sleep(3)
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_one = assert_one(int(before_balance), int(after_balance))
flag_three = assert_list([200, "可建仓余额不足", "1"],
[order_resp.status_code, msg, status])
self.assertTrue(flag_one)
def test_01(self):
"""
限价空单1单，市价多单1单，多单完全成交，空单部分成交，验证合约状态、用户余额
"""
logger.info("用例编号：45-1---限价空单1单，市价多单1单，多单完全成交，空单部分成交，验证合约状态、用户余额")
deal_price = 100000000
sell_num = 100000000
buy_num = 200000000
# 下一单多单、空单，部分成交
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=buy_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=sell_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),
int(after_sell_balance))
buy_flag = assert_one(int(self.sda_balance - buy_num),
int(after_buy_balance))
self.assertListEqual([True, True], [sell_flag, buy_flag])
def test_02(self):
"""
空单持仓，市价全平，多个对应委托，成交其中部分委托，验证委托状态、用户余额，手续费
"""
logger.info("用例编号：58-2---空单持仓，市价全平，多个对应委托，成交其中部分委托，验证委托状态、用户余额，手续费")
range_num = 10
price = 120 * 100000000
buy_num = 100 * 100000000
sell_num = 20 * 100000000
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(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_num=0))
sell_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=sell_resp.text)
logger.info("接口：{0}----返回信息：{1}".format(sda_order_create_url,
sell_resp.json()))
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), 9999773204030922)
flag_53 = assert_one(
self.sda_balance - int(price * sell_num * range_num / 100000000),
int(after_53_account_balance))
self.assertListEqual([True, True], [flag_51, flag_53])
def test_02(self):
"""
空单持仓中，部分市价平仓，对应委托成交，部分成交，未成交部分自动撤单，验证用户余额，委托状态，手续费
"""
logger.info(
"用例编号：53-2---空单持仓中，部分市价平仓，对应委托成交，部分成交，未成交部分自动撤单，验证用户余额，委托状态，手续费")
range_num = 10
price = 120 * 100000000
buy_num = 20 * 100000000
sell_num = 50 * 100000000
# 53用户下空单。
# time.sleep(2)
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=buy_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()))
# 平空单
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=sell_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(3)
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), 9999154560806185)
flag_53 = assert_one(
self.sda_balance - int(price * buy_num / 100000000),
int(after_53_account_balance))
self.assertListEqual([True, True], [flag_51, flag_53])
def test_01(self):
"""
多单持仓，市价全平，多个对应委托，成交其中部分委托，验证委托状态、用户余额、手续费
"""
logger.info("用例编号：67-1----多单持仓，市价全平，多个对应委托，成交其中部分委托，验证委托状态、用户余额、手续费")
range_num = 10
price = 20 * 100000000
buy_num = 10 * 100000000
sell_num = 2 * 100000000
sync_53_id = None
for i in range(range_num):
# 53用户下多单。
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(3)
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_num=0))
buy_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=buy_resp.text)
logger.info("接口：{0}----返回信息：{1}".format(sda_order_create_url,
buy_resp.json()))
# time.sleep(3)
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=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), 10000001845965764)
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("用例编号：63-1---多单持仓中，有对应委托成交，部分成交，未成交部分自动撤单，验证用户余额、委托状态，手续费")
range_num = 10
price = 20 * 100000000
buy_num = 5 * 100000000
sell_num = 2 * 100000000
# 53用户下多单。
# time.sleep(2)
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)
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=0))
buy_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=buy_resp.text)
logger.info("接口：{0}----返回信息：{1}".format(sda_order_create_url,
buy_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=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), 9999985889193153)
flag_53 = assert_one(
self.sda_balance - int(price * sell_num / 100000000),
int(after_53_account_balance))
self.assertListEqual([True, True], [flag_51, flag_53])
def test_02(self):
"""
市价空单5倍杠杆委托，正常下单。
"""
logger.info("用例编号：108-1--市价空单10倍杠杆委托，正常下单。")
price = 100000000
num = 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=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,
lever="10",
order_num=num))
logger.info("接口：{0}---返回信息：{1}".format(sda_order_create_url,
order_resp.json()))
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)
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"]
one_flag = assert_one(int(before_balance), int(after_balance))
list_flag = assert_list([200, "SUCCESS", "0"],
[order_resp.status_code, msg, status])
self.assertListEqual([True, True], [one_flag, list_flag])
def test_04(self):
"""
空单持仓，平空，与空单成交
"""
logger.info("用例编号：50-4---空单持仓，平空，与空单成交")
range_num = 10
price = 120 * 100000000
buy_num = 100 * 100000000
# 平空单
time.sleep(0.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=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()))
# 53用户下空单。
# time.sleep(2)
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_num=buy_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(3)
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_balance = 9999773204030922
flag_51 = assert_one(int(after_account_balance), int(flag_balance))
flag_53 = assert_one(
self.sda_balance - int(price * buy_num / 100000000),
int(after_53_account_balance))
self.assertListEqual([True, True], [flag_51, flag_53])
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_01(self):
"""
多单持仓中，部分限价平仓，验证持仓余额，平仓委托中状态，用户余额，手续费
"""
logger.info("用例编号：61-1---多单持仓中，部分平仓，验证持仓余额，平仓委托中状态，用户余额，手续费")
range_num = 10
price = 20 * 100000000
buy_num = 5 * 100000000
# 平多单
time.sleep(0.5)
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))
buy_sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=buy_resp.text)
logger.info("接口：{0}----返回信息：{1}".format(sda_order_create_url,
buy_resp.json()))
# 53用户下多单。
# time.sleep(2)
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=buy_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(3)
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=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), 9999991872982882)
flag_53 = assert_one(
self.sda_balance - int(price * buy_num / 100000000),
int(after_53_account_balance))
self.assertListEqual([True, True], [flag_51, flag_53])
def test_01(self):
"""
正常访问
"""
logger.info("用例编号：19-1---查询单个SDA合约账户信息接口，正常访问，验证接口状态、MSG、STATUS")
info_resp = self.session.post(url=base+sda_account_info_url, data=get_sda_account_info_param(sda_id=sda_id))
msg = JMESPathExtractor().extract(query="MSG", body=info_resp.text)
status = JMESPathExtractor().extract(query="STATUS", body=info_resp.text)
logger.info("接口：{0}----接口状态：{1}----接口返回信息：{2}".format(sda_account_info_url, info_resp.status_code, info_resp.json()))
self.assertListEqual([200, "SUCCESS", "0"], [info_resp.status_code, msg, status])
def test_01(self):
"""
正常访问
"""
logger.info("用例编号：201-1--查询首页接口测试，正常访问，验证接口状态、STATUS、MSG")
positons_resp = self.session.post(url=base + home_page_url,
data=home_page(version="1.3.2"))
msg = JMESPathExtractor().extract(query="MSG", body=positons_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=positons_resp.text)
print(msg, status, positons_resp.status_code)
def test_01(self):
"""
正常访问
"""
logger.info("用例编号：9-1---查询历史委托接口，正常访问，验证接口状态、MSG、STATUS")
history_resp = self.session.post(url=base+sda_order_get_history_url, data=get_sda_order_get_history_param(sda_id=sda_id))
msg = JMESPathExtractor().extract(query="MSG", body=history_resp.text)
status = JMESPathExtractor().extract(query="STATUS", body=history_resp.text)
logger.info("用户：{0}---接口：{1}--状态：{2}---返回信息：{3}".format(self.buyer, sda_order_get_history_url, history_resp.status_code, history_resp.json()))
self.assertListEqual([200, "SUCCESS", "0"], [history_resp.status_code, msg, status])
def tet_05(self):
"""
撤单接口，错误卖单ID撤单，验证接口返回状态、MSG、STATUS、OBJECT
"""
logger.info("用例编号：4-5---撤单接口，错误卖单ID撤单，验证接口返回状态、MSG、STATUS、OBJECT")
update_resp = self.session.post(url=base+update_revocation_status_url, data=get_update_revocation_status_param(_type=卖单, order_id="sajd56"))
status = JMESPathExtractor().extract(query="STATUS", body=update_resp.text)
msg = JMESPathExtractor().extract(query="MSG", body=update_resp.text)
OBJECT = JMESPathExtractor().extract(query="OBEJCT", body=update_resp.text)
logger.info("用户：{0}----url：{1}-----接口状态：{2}".format(BUYER, update_revocation_status_url, update_resp.status_code))
logger.info("撤单返回信息：{}".format(update_resp.json()))
self.assertListEqual([200, "订单不存在", "1"], [update_resp.status_code, msg, status])
def test_05(self):
"""
查询当前委托接口，pageSize参数传超出长度，currentPage参数超出长度。验证接口返回状态、MSG、STATUS
"""
logger.info("用例编号：3-5---查询当前委托接口，languageType参数传超出长度，currentPage参数超出长度。验证接口返回状态、MSG、STATUS")
resp = self.session.post(url=base+query_present_order_url, data=get_query_present_order_param(currentPage=10000, pageSize=15000))
status = JMESPathExtractor().extract(query="STATUS", body=resp.text)
msg = JMESPathExtractor().extract(query="MSG", body=resp.text)
OBJECT = JMESPathExtractor().extract(query="OBJECT", body=resp.text)
logger.info("用户：{0}-----url：{1}-----接口状态：{2}".format(BUYER, query_present_order_url, resp.status_code))
logger.info("查询当前委托返回信息：{}".format(resp.json()))
self.assertListEqual([200, "SUCCESS", None, "0"], [resp.status_code, msg, OBJECT, status])
def test_03(self):
"""
查询当前委托接口，currencyPage传参：""，pageSize传参：""，验证接口返回状态、MSG、STATUS
"""
logger.info("用例编号：3-3----查询当前委托接口，currencyPage传参：""，验证接口返回状态、MSG、STATUS")
resp = self.session.post(url=base+query_present_order_url, data=get_query_present_order_param(currentPage="",pageSize=""))
status = JMESPathExtractor().extract(query="STATUS", body=resp.text)
OBJECT = JMESPathExtractor().extract(query="OBJECT", body=resp.text)
msg = JMESPathExtractor().extract(query="MSG", body=resp.text)
logger.info("用户：{0}----url：{1}-----访问接口状态：{2}".format(BUYER, query_present_order_url, resp.status_code))
logger.info("查询当前委托返回信息：{}".format(resp.json()))
self.assertListEqual([200, "SUCCESS", "0"], [resp.status_code, msg, status])
def test_01(self):
"""
连续下N个多单，连续撤单，检查委托状态、用户余额
"""
logger.info("用例编号：109-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
lever = 100
# 下委托前查询可用余额
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(100):
# 下多单限价
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.限价,
lever=lever,
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)
def tearDown(self):
logout_resp = self.session.post(url=base + logout_url,
data=get_user_logout_param())
logout_status = JMESPathExtractor().extract(query="MSG",
body=logout_resp.text)
logger.info("用户：{0}-------退出状态：{1}".format(BUYER, logout_status))
self.session.close()
sell_logout_resp = self.session.post(url=base + logout_url,
data=get_user_logout_param())
sell_logout_status = JMESPathExtractor().extract(
query="MSG", body=sell_logout_resp.text)
logger.info("用户：{0}-------退出状态：{1}".format(SELLER, sell_logout_status))
self.sell_session.close()
def test_02(self):
"""
限价空单委托，正常下单。
"""
logger.info("用例编号：106-2----限价空单10倍杠杆委托，正常下单。")
num = 1000000000
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)
# 查询当前股价
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, 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=限价,
lever="10",
order_price=price,
order_num=num,))
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"] # 委托状态
# 查询委托后可用余额
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_one = assert_one(int(before_balance), int(after_balance) + int(price * num / 10 / 100000000))
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_01(self):
"""
查询交易对接口，正常访问，验证接口状态、MSG、STATUS、OBJECT
"""
logger.info("用例编号：5-1---查询交易对接口，正常访问，验证接口状态、MSG、STATUS、OBJECT")
resp = self.session.post(url=base + query_transtion_pari_url,
data=get_query_transtion_pair_param())
logger.info("用户：{0}----URL：{1}-----接口状态：{2}".format(
BUYER, query_transtion_pari_url, resp.status_code))
status = JMESPathExtractor().extract(query="STATUS", body=resp.text)
msg = JMESPathExtractor().extract(query="MSG", body=resp.text)
logger.info("查询交易对接口返回信息：{}".format(resp.json()))
self.assertListEqual([200, "SUCCESS", "0"],
[resp.status_code, msg, status])
def test_02(self, number, transtion_id, main_currency_id, target_currency_id, buy_price, buy_num, sell_price, sell_num):
"""
余额刚好，下单成功
"""
logger.info("<<==========================================================================================================================>")
logger.info("用例说明： 编号：90-2-%s， 余额刚好下限价买单" % number)
logger.info("买家账号：{0}--------卖家账号：{1}".format(BUYER, SELLER))
logger.info("-----交易对ID：{0}-----主币ID：{1}-----目标币ID：{2}".format(transtion_id, main_currency_id, target_currency_id))
ConnectMysql(_type=mysql_type).update_order_status(transtion_id=transtion_id, order_type=1, order_status=1)
ConnectMysql(_type=mysql_type).update_order_status(transtion_id=transtion_id, order_type=2, order_status=1)
ConnectRedis(_type=redis_type).clear_redis(get_redis_name(transtion_id))
"""
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=main_currency_id, balance_value=990000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=target_currency_id, balance_value=990000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=SELLER, currency_id=main_currency_id, balance_value=990000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=SELLER, currency_id=target_currency_id, balance_value=990000000000000)
"""
num_min, price_min = ConnectMysql(_type=mysql_type).query_currency_min(transtion_id=transtion_id)
value = int(num_min) * int(price_min)
buy_price, sell_price, buy_num, sell_num = int(buy_price), int(sell_price), int(buy_num), int(sell_num)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=main_currency_id, balance_value=value)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=target_currency_id, balance_value=9900000000000000)
before_buy_main, before_buy_target, before_sell_main, before_sell_target = query_user_balance_value(
buyer=BUYER, seller=SELLER, main_currency_id=main_currency_id, target_currency_id=target_currency_id
)
login_url = base_url + test_data.get("login_url")
buy_url = base_url + test_data.get("order_reservations_url")
session = requests.session()
session.post(url=login_url, headers=login_header, data=get_login_param(user=BUYER, user_password=user_password))
resp = session.post(url=buy_url, data=get_order_reservations_param(transtion_id, 0, price=price_min, num=num_min))
logger.info("下单前买家主币余额：{0}-----下买单价格：{1}-----------下买单数量：{2}".format(before_buy_main, price_min, num_min))
session.close()
logger.info("下买单返回信息：{}".format(resp.json()))
after_buy_main, after_buy_target, after_sell_main, after_sell_target = query_user_balance_value(
buyer=BUYER, seller=SELLER, main_currency_id=main_currency_id, target_currency_id=target_currency_id, transaction_id=transtion_id,
)
assert_word = JMESPathExtractor().extract(query="MSG", body=resp.text)
assert_status = JMESPathExtractor().extract(query="STATUS", body=resp.text)
assert_list = [assert_word, assert_status]
logger.info(" 下单前买家主币余额：{0}--------- 下单后买家主币余额：{1}-------成交金额{2}".format(before_buy_main, after_buy_main, math.ceil(value/100000000)))
logger.info("下单前买家目标币余额：{0}---------下单后买家目标币余额：{1}".format(before_buy_target, after_buy_target))
self.assertIn(int(before_buy_main) - int(after_buy_main) - math.ceil(value/100000000), [0, 1])
self.assertIn(int(before_buy_target) - int(after_buy_target), [0, 1])
self.assertListEqual(assert_list, ["SUCCESS", "0"])
def test_01(self):
"""
做市商撤销订单
"""
self.sell_url = self.base_url + "/ordersellerrest.do"
sell_data = {
"sellerOrderNum": 10000000,
"sellerOrderPrice": 500000,
"languageType": 3,
"timeStamp": "1538118050702",
"transtionId": transtion_id,
"userMail": "*****@*****.**",
"userPass": "******"
}
self.sell_resp = self.requ.post(url=self.sell_url, data=sell_data)
order_id = JMESPathExtractor().extract(query="OBJECT.sellerOrderId",
body=self.sell_resp.text)
time.sleep(4)
data = {
"userMail": "*****@*****.**",
"userPass": "******",
"orderId": order_id,
"type": "2"
}
self.resp_3 = self.requ.post(url=self.url, data=data)
print(self.resp_3.status_code)
self.assertEqual(self.resp_3.json()["MSG"], "SUCCESS")
print("撤单接口返回信息:", self.resp_3.json())
def test_01(self):
"""
多单持仓中，部分市价平仓，无对应委托成交，自动撤单，验证用户余额、委托状态
"""
logger.info("用例编号：62-1---多单持仓中，部分市价平仓，无对应委托成交，自动撤单，验证用户余额、委托状态")
range_num = 10
price = 20*100000000
buy_num = 5*100000000
before_buy_account_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id)
before_buy_account_balance = before_buy_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_price_type=市价, order_price=price, order_num=buy_num
))
sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_resp.text)
logger.info("接口：{0}----返回信息：{1}".format(sda_order_create_url, buy_resp.json()))
# time.sleep(2)
after_buy_account_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session,
sda_id=sda_id)
after_buy_account_balance = after_buy_account_dict["balance"]
flag = assert_one(int(before_buy_account_balance), int(after_buy_account_balance))
self.assertTrue(flag)
def test_04(self):
"""
正常提现
"""
check_user_param = {
"Email": "*****@*****.**",
"Signature": "22e63226e0ae4111b6161a2bd1834721"
}
withdraw_param = {
"Email": "*****@*****.**",
"number": 3,
"Signature": "ac0f5266e552fcff5b64d99d80ffdd31",
}
logger.info(
"分割线----------------------------------------------------------------------------------------------------------------"
)
logger.info("用户编号：29-4-----测试提现")
resp = self.session.post(url=base_url + login_url,
headers=headers,
data=get_login_param(user=BUYER,
user_password=password))
status = JMESPathExtractor().extract(query="MSG", body=resp.text)
logger.info(
"用户：{0}------登陆url：{1}-------接口返回状态：{2}-------登陆状态{3}".format(
BUYER, login_url, resp.status_code, status))
check_user_resp = self.session.post(url=base_url + check_user_url,
data=check_user_param)
withdraw_resp = self.session.post(url=base_url + withdraw_url,
data=withdraw_param)
print(withdraw_resp.status_code)
print(withdraw_resp.json())
def test_01(self):
"""
转出清除赠金测试
:return:
"""
logger.info("用例编号：140-1----把用户转入的钱全部转出，赠金清除为0")
balance = 30 * 100000000
sda_balance = 30 * 100000000
ConnectMysql(_type=mysql_type).sda_update_user_platform_freeze_balance(
user_mail=self.buyer, sda_id=sda_id, balance=balance)
# 更新可用余额
ConnectRedis(_type=redis_type,
db=4).sda_clear_user_balance(user_id=self.user_id,
keys=sda_id)
ConnectMysql(_type=mysql_type).sda_clear_balance_value(
user_id=self.user_id, sda_id=sda_id)
ConnectMysql(_type=mysql_type).sda_update_user_balance(
user_id=self.user_id, sda_id=sda_id, sda_balance=sda_balance)
time.sleep(0.2)
withdraw_dict = sda_account_withdraw(user=self.buyer,
session=self.session,
sda_id=sda_id,
amount=balance)
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=withdraw_dict.text)
account_info_dict = account_info_sync(sync_id=sync_id,
user=self.buyer,
session=self.session,
sda_id=sda_id)
flag = assert_one(int(account_info_dict["balance"]), 0)
self.assertEqual(flag, True)
def test_01(self):
"""
正常访问。
"""
logger.info("用例编号：17-1---查询用户资金余额接口，正常访问，验证接口状态、MSG、STATUS")
balance_resp = self.session.post(url=base + sda_fund_balance_url,
data=get_sda_fund_balance_param())
logger.info("用户：{0}--接口：{1}--状态：{2}--返回信息：{3}".format(
self.buyer, sda_fund_balance_url, balance_resp.status_code,
balance_resp.json()))
status = JMESPathExtractor().extract(query="STATUS",
body=balance_resp.text)
msg = JMESPathExtractor().extract(query="MSG", body=balance_resp.text)
self.assertListEqual([200, "SUCCESS", "0"],
[balance_resp.status_code, msg, status])
def test_01(self):
"""
正常访问，验证接口状态、STATUS、MSG
"""
logger.info("用例编号：4-1----查询SDA列表信息，正常访问，验证接口状态、STATUS、MSG")
list_resp = self.session.post(url=base + sda_get_list_url,
data=get_sda_get_list_param())
logger.info("接口：{0}---状态：{1}--返回信息：{2}".format(sda_get_list_url,
list_resp.status_code,
list_resp.json()))
msg = JMESPathExtractor().extract(query="MSG", body=list_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=list_resp.text)
self.assertListEqual([200, "0", "SUCCESS"],
[list_resp.status_code, status, msg])
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):
"""
正常访问
"""
logger.info("用例编号：13-1---资金流水接口测试类，正常访问，验证接口状态、MSG、STATUS")
fund_resp = self.session.post(
url=base + query_sda_fund_record_url,
data=get_sda_query_sda_fund_record_param())
msg = JMESPathExtractor().extract(query="MSG", body=fund_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=fund_resp.text)
logger.info("用户：{0}---接口：{1}--状态：{2}---返回信息：{3}".format(
self.buyer, query_sda_fund_record_url, fund_resp.status_code,
fund_resp.json()))
self.assertListEqual([200, "SUCCESS", "0"],
[fund_resp.status_code, msg, status])
