def test_06(self):
"""
时间空单，用户可用余额为0，验证是否下单成功。
:return:
"""
deal_price = 100000000
deal_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=0)
# min_max = ConnectMysql(_type=mysql_type).sda_query_contract_min(sda_id=sda_id)
order_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_num=deal_num))
msg = JMESPathExtractor().extract(query="MSG", body=order_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=order_resp.text)
logger.info("用户：{0}--接口：{1}---状态：{2}---返回信息：{3}".format(
self.buyer, sda_order_create_url, order_resp.status_code,
order_resp.json()))
flag = assert_list([200, "可建仓余额不足", "1"],
[order_resp.status_code, msg, status])
self.assertTrue(flag)
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):
"""
用户余额为0，下市价买单，随机金额，随机数量验证接口状态、MSG、STATUS
"""
warnings.simplefilter("ignore", ResourceWarning)
main_currency_id, target_currency_id = ConnectMysql(
_type=mysql_type).query_main_target_currency(
transtion_id=transtion_id)
ConnectMysql(_type=mysql_type).update_balance_value(
user_mail=BUYER, currency_id=main_currency_id, balance_value=0)
num_min, price_min = ConnectMysql(_type=mysql_type).query_currency_min(
transtion_id=transtion_id)
random_price = random.randrange(int(price_min),
int(price_min) * 999999,
int(price_min))
random_num = random.randrange(int(num_min),
int(num_min) * 999999, int(num_min))
logger.info("用例编号：7-1---用户余额为0，下市价买单，验证接口状态、MSG、STATUS")
resp = self.session.post(url=base + order_reservations_url,
data=get_order_reservations_param(
transtion_id=transtion_id,
order_type=市价,
price=random_price,
num=random_num))
msg = JMESPathExtractor().extract(query="MSG", body=resp.text)
status = JMESPathExtractor().extract(query="STATUS", body=resp.text)
logger.info("用户：{0}----URL：{1}-----接口状态：{2}".format(
BUYER, order_reservations_url, resp.status_code))
logger.info("下市价买单返回信息：{}".format(resp.json()))
self.assertListEqual([200, "下单失败", "1"],
[resp.status_code, msg, status])
def test_01(self):
"""
限价卖\买：while（余额足够）{A创建卖单，B买入}， 全部成交 手续费 == 2/1000
交易对：BTC/USDT
A卖单等差递增
UserA_SellOrderPrice = 98
UserA_SellOrderNum = 1,2,3,4,5
B买单价格
UserB_BuyOrderPrice = 100
UserB_BuyOrderNum= 15
"""
# 清除redis，mysql中btc/usdt的买卖单数据
ConnectRedis().clear_redis(name=["1buy", "1sell"])
ConnectMysql().update_order_status(transtion_id=1, order_type=1, order_status=2)
ConnectMysql().update_order_status(transtion_id=1, order_type=2, order_status=2)
self.test_buyer = Base(user="******")
self.test_seller = Base(user="******")
logger.info("测试用例说明：".format(TestCase.setUp.__doc__))
# 下单前查询买卖双发的主币和目标币余额
self.before_deal_seller_main_balance_value = self.test_seller.User_balance_details(currency_id=1)
self.before_deal_seller_deputy_balance_value = self.test_seller.User_balance_details(currency_id=2)
self.before_deal_buyer_main_balance_value = self.test_buyer.User_balance_details(currency_id=1)
self.before_deal_buyer_deputy_balance_value = self.test_buyer.User_balance_details(currency_id=2)
logger.info("买入之前买家主币余额：{0}-----买入之前买家目标币余额：{1}".format(self.before_deal_buyer_main_balance_value, self.before_deal_buyer_deputy_balance_value))
logger.info("买入之前卖家的主币余额：{0}------买入之前卖家的目标币余额{1}".format(self.before_deal_seller_main_balance_value, self.before_deal_seller_deputy_balance_value))
self.buy_price, self.sell_price = 100, 98
self.buy_num = 15
self.sell_num = [1, 2, 3, 4, 5]
self.sell_id_list = []
for i in range(len(self.sell_num)):
self.sell_resp = self.test_seller.SellOrder(transtion_id=1, price=self.sell_price, num=self.sell_num[i], order_type=0)
self.sell_order_id = JMESPathExtractor().extract(query="OBJECT.sellerOrderId", body=self.sell_resp.text)
self.sell_id_list.append(self.sell_order_id)
time.sleep(1)
logger.info("下卖单返回信息：{0}".format(self.sell_resp.json()))
self.buy_resp = self.test_buyer.OrderReservations(transtion_id=1, price=self.buy_price, num=self.buy_num, order_type=0)
buy_order_id = JMESPathExtractor().extract(query="OBJECT.buyerOrderId", body=self.buy_resp.text)
logger.info("下买单返回信息：{0}".format(self.buy_resp.json()))
for i in self.sell_id_list:
order_status = ConnectMysql().get_Order_Status(order_id=i, order_type=2)
logger.info("卖单Id：{0}----订单状态：{1}".format(i, order_status))
logger.info("买单ID：{0}----订单状态：{1}".format(buy_order_id, ConnectMysql().get_Order_Status(order_id=buy_order_id, order_type=1)))
self.after_deal_seller_main_balance_value = self.test_seller.User_balance_details(currency_id=1)
self.after_deal_seller_deputy_balance_value = self.test_seller.User_balance_details(currency_id=2)
self.after_deal_buyer_main_balance_value = self.test_buyer.User_balance_details(currency_id=1)
self.after_deal_buyer_deputy_balance_value = self.test_buyer.User_balance_details(currency_id=2)
logger.info("买入之后买家主币余额：{0}-------买入之后买家目标币余额：{1}".format(self.after_deal_buyer_main_balance_value, self.after_deal_buyer_deputy_balance_value))
logger.info("买入之后卖家主币余额：{0}------买入之后卖家目标币余额：{1}".format(self.after_deal_seller_main_balance_value, self.after_deal_seller_deputy_balance_value))
logger.info("成交金额：{0}".format(self.buy_num*self.sell_price))
def test_01(self):
"""
下限价多单单，下单数量大于可用余额
"""
logger.info("用例编号：22-1---下限价多单，下单数量大于可用余额")
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_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,
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.assertListEqual([True, True], [flag_one, flag_three])
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_03(self, number, transtion_id, main_currency_id, target_currency_id, buy_price, buy_num, sell_price, sell_num):
logger.info("<<==========================================================================================================================>")
logger.info("用例说明： 编号：90-3-%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)
buy_price, sell_price, buy_num, sell_num = int(buy_price), int(sell_price), int(buy_num), int(sell_num)
sell_num_list = [int(num_min) - 1, 0]
for i in sell_num_list:
with self.subTest():
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=SELLER, currency_id=main_currency_id, balance_value=9900000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=SELLER, currency_id=target_currency_id, balance_value=i)
login_url = base_url + test_data.get("login_url")
sell_url = base_url + test_data.get("sell_order_url")
session = requests.session()
session.post(url=login_url, headers=login_header, data=get_login_param(user=SELLER, user_password=user_password))
resp = session.post(url=sell_url, data=get_sell_order_param(transtion_id, 0, sell_price, num_min))
session.close()
logger.info("下卖单返回信息：{}".format(resp.json()))
assert_word = JMESPathExtractor().extract(query="MSG", body=resp.text)
assert_status = JMESPathExtractor().extract(query="STATUS", body=resp.text)
assert_list = [assert_word, assert_status]
self.assertListEqual(assert_list, ["最小交易单位不正确", "1"])
def test_02(self):
"""
下限价空单，撤单，验证用户余额，委托保证金余额
"""
logger.info("用例编号：7-2--下多单，撤单，验证用户余额，委托保证金余额，")
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=990000000000000)
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"]
price = int(int(now_stock_price) * 0.95)
# 下单前查询用户的余额
buy_balance = self.session.post(url=base+sda_account_asset_detail_get_url, data=get_sda_account_asset_detail_get_param())
buy_balance_value = JMESPathExtractor().extract(query="OBJECT.PNLList[0].availableMargin",body=buy_balance.text)
buy_entrust_value = JMESPathExtractor().extract(query="OBJECT.PNLList[0].entrustMargin", body=buy_balance.text)
logger.info("用户：{0}---接口：{1}---状态：{2}---下单前可用保证金：{3}--委托保证金：{4}".format(self.buyer, sda_account_asset_detail_get_url,buy_balance.status_code, buy_balance_value, buy_entrust_value))
# 下限价空单委托
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_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)
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()))
cancel_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=cancel_resp.text)
cancel_msg = JMESPathExtractor().extract(query="MSG", body=cancel_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_buy_balance_value = JMESPathExtractor().extract(query="OBJECT.PNLList[0].availableMargin",body=after_buy_balance.text)
after_buy_entrust_value = JMESPathExtractor().extract(query="OBJECT.PNLList[0].entrustMargin", body=after_buy_balance.text)
logger.info("用户：{0}---接口：{1}---状态：{2}---下单后可用保证金：{3}---下单后委托保证金：{4}".format(self.buyer, sda_account_asset_detail_get_url,after_buy_balance.status_code, after_buy_balance_value, after_buy_entrust_value))
order_id_flag = assert_list([buy_order_id, 200, "SUCCESS"], [cancel_order_id, cancel_resp.status_code, cancel_msg])
available_margin_flag = assert_one(int(buy_balance_value), int(after_buy_balance_value))
entrust_margin_flag = assert_one(int(buy_entrust_value), int(after_buy_entrust_value))
self.assertListEqual([True, True, True], [available_margin_flag, entrust_margin_flag, order_id_flag])
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 clear_all_data(sda_id, user_mail, user_id):
"""
清除用户的合约下所有的mysql和redis数据
:param sda_id: 合约ID
:param user_id: 用户ID
:return:
"""
ConnectMysql(_type=mysql_type).sda_delete_user_order(sda_id=sda_id)
ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id)
ConnectRedis(_type=redis_type,
db=4).sda_clear_user_balance(user_id=user_id, keys=sda_id)
ConnectMysql(_type=mysql_type).sda_clear_balance_value(user_id=user_id,
sda_id=sda_id)
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_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):
"""
正常下限价买单，验证返回接口状态、MSG、STATUS
"""
logger.info("用例编号：2-1-----正常下限价买单，验证返回接口状态、MSG、STATUS")
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=transtion_id))
resp = self.session.post(url=base + order_reservations_url,
data=get_order_reservations_param(
transtion_id=transtion_id,
order_type=限价,
price=price,
num=num))
status = JMESPathExtractor().extract(query="MSG", body=resp.text)
buy_num = JMESPathExtractor().extract(query="STATUS", body=resp.text)
buy_order_id = JMESPathExtractor().extract(query="OBJECT.buyerOrderId",
body=resp.text)
logger.info("用户：{0}----url：{1}-----接口状态：{2}-----下单状态：{3}".format(
BUYER, order_reservations_url, resp.status_code, status))
logger.info("下限价买单返回信息：{}".format(resp.json()))
self.assertEqual([200, "SUCCESS", "0"],
[resp.status_code, status, buy_num])
time.sleep(6)
self.session.post(url=base + update_revocation_status_url,
data=get_update_revocation_status_param(
_type=买单, order_id=buy_order_id))
def test_03(self):
"""
用户余额正常，超额划转资金，验证接口状态、STATUS、MSG
"""
logger.info(
"用例编号：2-3------------资金划转接口测试类，用户余额正常，超额划转资金，验证接口状态、STATUS、MSG")
ConnectMysql(_type=mysql_type).update_balance_value(
user_mail=self.buyer,
currency_id=currency_id,
balance_value=100000000000)
deposit_resp = self.session.post(url=base + sda_account_deposit_url,
data=get_sda_account_deposit_param(
sda_id=sda_id,
amount=200000000000))
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)
# _object = JMESPathExtractor().extract(query="OBJECT", body=deposit_resp.text)
flag = assert_list([200, "1", "平台账户余额不足"],
[deposit_resp.status_code, status, msg])
self.assertTrue(flag)
def delete_all_order(sda_id):
"""
清除合约下所有订单
:param sda_id: 合约ID
:return:
"""
ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id)
ConnectMysql(_type=mysql_type).sda_delete_order(sda_id=sda_id)
def test_04(self):
"""
用户可用保证金为0，空单，检查是否下单成功
"""
logger.info("用例编号：20-4---用户可用保证金为0，限价空单，检查是否下单成功")
deal_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=0)
# 查询当前股价
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)
# min_max = ConnectMysql(_type=mysql_type).sda_query_contract_min(sda_id=sda_id)
order_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))
msg = JMESPathExtractor().extract(query="MSG", body=order_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=order_resp.text)
logger.info("用户：{0}--接口：{1}---状态：{2}---返回信息：{3}".format(
self.buyer, sda_order_create_url, order_resp.status_code,
order_resp.json()))
flag = assert_list([200, "该订单将会触发您所持仓位的强平", "1"],
[order_resp.status_code, msg, status])
self.assertTrue(flag)
def test_01(self):
"""
下限价多单，撤单，验证用户余额，委托保证金余额
"""
logger.info("用例编号：7-1--下多单，撤单，验证用户余额，委托保证金余额，")
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=990000000000000)
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"]
# 下多单限价
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)
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()))
cancel_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=cancel_resp.text)
sync_id = JMESPathExtractor().extract(query="syncLockKey", body=cancel_resp.text)
cancel_msg = JMESPathExtractor().extract(query="MSG", body=cancel_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"]
order_id_flag = assert_list([buy_order_id, 200, "SUCCESS"], [cancel_order_id, cancel_resp.status_code, cancel_msg])
available_margin_flag = assert_one(int(before_balance), int(after_balance) )
self.assertListEqual([True, True], [available_margin_flag, order_id_flag])
def test_02(self, transtion_id):
"""
循环100次下限价卖单，撤单，检验撤单后余额、冻结金额
"""
for i in range(1):
with self.subTest():
logger.info("<<==========================================================================================================================>")
logger.info("编号：83--2--ID：{0}--------循环下限价卖单、撤单100次检查用户余额".format(transtion_id))
seller = Base(user=SELLER)
mySetUp(transtion_id=transtion_id, mysql_type=mysql_type,redis_type=redis_type,buyer=BUYER,seller=SELLER,balance_value=balance_value)
warnings.simplefilter("ignore", ResourceWarning)
before_sell_main_resp, before_sell_target_resp = seller.query_user_main_target_balance(mysql_type, transtion_id)
before_sell_target_balance_value = JMESPathExtractor().extract(query="OBJECT.balanceValue", body=before_sell_target_resp.text)
before_sell_target_freezingAssets = JMESPathExtractor().extract(query="OBJECT.freezingAssets", body=before_sell_target_resp.text)
num_min, price_min = ConnectMysql(mysql_type).query_currency_min(transtion_id)
for k in range(20):
time.sleep(5)
logger.info("- - -- - -- - - -- - - -- - - - - - - - -- - - - - -- -- - - -- - - - - - -- - - -- - - - - - -- - - -- - -- -")
sell_price = random.randrange(int(price_min), int(price_min) * 999999, int(price_min))
sell_num = random.randrange(int(num_min), int(num_min) * 999999, int(num_min))
sell_order_text = seller.SellOrder(transtion_id=transtion_id, price=sell_price, num=sell_num, order_type=限价)
sell_order_id = JMESPathExtractor().extract(query="OBJECT.sellerOrderId", body=sell_order_text.text)
sell_order_status = ConnectMysql(mysql_type).get_Order_Status(order_id=sell_order_id, order_type=卖单)
logger.info("买单状态：{}".format(sell_order_status))
time.sleep(5)
seller.updateRevocationStatus(type=卖单, orderId=sell_order_id)
update_sell_order_status = ConnectMysql(mysql_type).get_Order_Status(order_id=sell_order_id, order_type=卖单)
logger.info("撤单后订单状态：{}".format(update_sell_order_status))
after_sell_main_update_resp, after_sell_update_resp = seller.query_user_main_target_balance(mysql_type, transtion_id)
seller.close()
after_sell_target_update_balance = JMESPathExtractor().extract(query="OBJECT.balanceValue", body=after_sell_update_resp.text)
after_sell_target_update_freezingAssets = JMESPathExtractor().extract(query="OBJECT.freezingAssets", body=after_sell_update_resp.text)
x = '{:.8f}'.format(float(before_sell_target_freezingAssets))
y = '{:.8f}'.format(float(after_sell_target_update_freezingAssets))
logger.info("循环下单撤单100次后目标币余额：{0}------起始目标币余额{1}".format(after_sell_target_update_balance, before_sell_target_balance_value))
logger.info("循环下单撤单100次后目标币冻结金额：{0}--------起始目标币冻结金额{1}".format(y, x))
self.assertEqual(int(before_sell_target_balance_value), int(after_sell_target_update_balance))
def test_02(self):
"""
有委托的情况下禁止转出余额
:return:
"""
logger.info("用例编号：140-2---有委托的情况下禁止转出")
info_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
now_stock_price = int(info_dict["stockPrice"])
deal_num = 1 * 100000000
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)
# 下委托
sda_order_create(user=self.buyer,
session=self.session,
sda_id=sda_id,
order_type=多单,
order_price_type=限价,
order_price=now_stock_price,
order_num=deal_num)
fund_balance_dict = sda_fund_balance(user=self.buyer,
session=self.session,
sda_id=sda_id)
time.sleep(0.2)
flag = assert_one(int(fund_balance_dict["withdrawMargin"]), 0)
self.assertEqual(flag, True)
def tet_04(self):
"""
撤单接口，下卖单正常撤单，验证接口返回状态、MSG、STATUS、OBJECT
"""
logger.info("用例编号：4-4---撤单接口，下卖单正常撤单，验证接口返回状态、MSG、STATUS、OBJECT")
ConnectMysql(_type=mysql_type).update_order_status(transtion_id=transtion_id, order_type=1, order_status=1)
ConnectRedis(_type=redis_type).clear_redis(get_redis_name(transtion_id=transtion_id))
sell_resp = self.session.post(url=base+sell_order_url, data=get_sell_order_param(transtion_id=transtion_id,order_type=限价,price=price,num=num))
sell_order_id = JMESPathExtractor().extract(query="OBJECT.sellerOrderId", body=sell_resp.text)
logger.info("URL：{0}-----卖单接口返回状态：{1}-------卖单返回信息：{2}".format(sell_order_url,sell_resp.status_code, sell_resp.json()))
time.sleep(5)
update_resp = self.session.post(url=base+update_revocation_status_url, data=get_update_revocation_status_param(_type=卖单,order_id=sell_order_id))
status = JMESPathExtractor().extract(query="STATUS", body=update_resp.text)
msg = JMESPathExtractor().extract(query="MSG", body=update_resp.text)
OBJECT = JMESPathExtractor().extract(query="OBJECT", 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, "SUCCESS", "0"], [update_resp.status_code, msg, status])
def test_01(self, number, transtion_id, main_currency_id,
target_currency_id, buy_price, buy_num, sell_price, sell_num):
"""
编号：45-1
限价买单，不收手续费，限价卖单，收取手续费
"""
logger.info(
"<<==========================================================================================================================>"
)
logger.info("用例说明： 编号：45-1-%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))
buy_price, sell_price, buy_num, sell_num = int(buy_price), int(
sell_price), int(buy_num), int(sell_num)
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)
test_buyer = Base(user=BUYER)
buy_order_id = test_buyer.OrderReservations(transtion_id=transtion_id,
price=buy_price,
num=buy_num,
order_type=0)
time.sleep(1)
test_seller = Base(user=SELLER)
sell_order_id = test_seller.SellOrder(transtion_id=transtion_id,
price=sell_price,
num=sell_num,
order_type=0)
test_buyer = Base(user=BUYER)
buy_update_resp = test_buyer.updateRevocationStatus(
type=1, orderId=buy_order_id)
buy_assert_list = [
JMESPathExtractor().extract(query="MSG",
body=buy_update_resp.text),
JMESPathExtractor().extract(query="STATUS",
body=buy_update_resp.text)
]
test_seller = Base(user=SELLER)
sell_update_resp = test_seller.updateRevocationStatus(
type=2, orderId=sell_order_id)
sell_assert_list = [
JMESPathExtractor().extract(query="MSG",
body=sell_update_resp.text),
JMESPathExtractor().extract(query="STATUS",
body=sell_update_resp.text)
]
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,
order_id=sell_order_id)
buy_order_status = ConnectMysql(_type=mysql_type).get_Order_Status(
order_id=buy_order_id, order_type=1)
sell_order_status = ConnectMysql(_type=mysql_type).get_Order_Status(
order_id=sell_order_id, order_type=2)
logger.info("交易后买单状态：{0}-----交易后卖单状态：{1}".format(
buy_order_status, sell_order_status))
balance_dict = {
"before_buy_main_balance": before_buy_main,
"before_buy_target_balance": before_buy_target,
"before_sell_main_balance": before_sell_main,
"before_sell_target_balance": before_sell_target,
"after_buy_main_balance": after_buy_main,
"after_buy_target_balance": after_buy_target,
"after_sell_main_balance": after_sell_main,
"after_sell_target_balance": after_sell_target,
}
self.assertListEqual(buy_assert_list, ["订单已被成交", "1"])
self.assertListEqual(sell_assert_list, ["订单已被成交", "1"])
flag_list = count_balance(free_type="buy_free",
deal_price=buy_price,
deal_num=buy_num,
**balance_dict)
self.assertNotIn(False, flag_list)
def test_01(self):
"""
正常访问，验证接口状态、MSG、STATUS，验证bb账户余额，合约账户余额
"""
logger.info(
"用例编号：3-1---合约账户转到币币账户接口测试类--正常访问，验证接口状态、MSG、STATUS，验证bb账户余额、合约账户余额"
)
amount = 100000000
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=10000000000)
# 转出前查询bb账户余额
before_bb_account_resp = self.session.post(
url=base + 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"]
# 转出
withdraw_resp = self.session.post(url=base + sda_account_withdraw_url,
data=get_sda_account_withdraw_param(
sda_id=sda_id, amount=amount))
msg = JMESPathExtractor().extract(query="MSG", body=withdraw_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=withdraw_resp.text)
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=withdraw_resp.text)
logger.info("用户：{0}--接口：{1}---状态：{2}--转出金额：{3}--返回信息：{4}".format(
self.buyer, sda_account_withdraw_url, withdraw_resp.status_code,
amount, withdraw_resp.json()))
# time.sleep(3)
# 转出后查询合约账户余额
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 + 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))
logger.info("转出金额：{}".format(amount))
self.assertListEqual([200, "SUCCESS", "0"],
[withdraw_resp.status_code, msg, status])
self.assertEqual(
int(before_currency_balance) + amount, int(after_currency_balance))
self.assertEqual(
int(before_account_balance) - int(amount),
int(after_account_balance))
def test_01(self):
"""
分别喂多、空单，价格随机，数量随机
:return:
"""
self.sda_balance = 999999900000000
self.buyer = "*****@*****.**"
self.seller = "*****@*****.**"
self.session = requests.session()
login_resp = self.session.post(url=base + login_url,
headers=headers,
data=get_login_param(
user=self.buyer,
user_password=password))
login_status = JMESPathExtractor().extract(query="MSG",
body=login_resp.text)
logger.info("用户：{0}----接口：{1}----接口状态：{2}----登陆状态：{3}".format(
self.buyer, login_url, login_resp.status_code, login_status))
self.cookies = self.session.cookies
self.sell_session = requests.session()
sell_login_resp = self.sell_session.post(url=base + login_url,
headers=headers,
data=get_login_param(
user=self.seller,
user_password=password))
sell_login_status = JMESPathExtractor().extract(
query="MSG", body=sell_login_resp.text)
logger.info("用户：{0}----接口：{1}----接口状态：{2}-----登陆状态：{3}".format(
self.seller, login_url, sell_login_resp.status_code,
sell_login_status))
self.sell_cookies = self.sell_session.cookies
self.user_id = JMESPathExtractor().extract(query="OBJECT.userId",
body=login_resp.text)
self.seller_id = JMESPathExtractor().extract(query="OBJECT.userId",
body=sell_login_resp.text)
# 2个用户更新可用余额
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=self.sda_balance)
ConnectRedis(_type=redis_type,
db=4).sda_clear_user_balance(user_id=self.seller_id,
keys=sda_id)
ConnectMysql(_type=mysql_type).sda_clear_balance_value(
user_id=self.seller_id, sda_id=sda_id)
ConnectMysql(_type=mysql_type).sda_update_user_balance(
user_id=self.seller_id,
sda_id=sda_id,
sda_balance=self.sda_balance)
info_dict = market_info_get(user=self.buyer,
session=self.session,
sda_id=sda_id)
now_stock_price = int(int(info_dict["stockPrice"]) / 1000000)
for i in range(100):
random_price = random.randint(now_stock_price - 100,
now_stock_price + 100) * 1000000
random_num = random.randint(1, 10) * 100000000
print("price", random_price)
print("num", random_num)
buy_resp = self.session.post(url=base + order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=多单,
order_price_type=限价,
order_price=random_price,
order_num=random_num,
))
time.sleep(0.1)
order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
body=buy_resp.text)
print("buy order id ：", order_id)
sell_resp = self.sell_session.post(url=base + order_create_url,
data=get_sda_order_create_param(
sda_id=sda_id,
order_type=空单,
order_price_type=限价,
order_price=random_price,
order_num=random_num))
sell_order_id = JMESPathExtractor().extract(query="OBJECT.orderId",
body=sell_resp.text)
print("sell order id ：", sell_order_id)
def test_01(self, number, transtion_id, main_currency_id,
target_currency_id, buy_price, buy_num, sell_price, sell_num):
"""
编号：53-1
市商限价买单，不收手续费，撤单
"""
logger.info(
"<<==========================================================================================================================>"
)
logger.info("用例说明：编号：53-1-%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)
buy_price, sell_price, buy_num, sell_num = int(buy_price), int(
sell_price), int(buy_num), int(sell_num)
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)
test_buyer = Base(user=BUYER)
buy_order_id = test_buyer.OrderReservations(transtion_id=transtion_id,
price=buy_price,
num=buy_num,
order_type=0)
test_buyer = Base(user=BUYER)
buy_update_resp = test_buyer.updateRevocationStatus(
type=1, orderId=buy_order_id)
buy_assert_list = [
JMESPathExtractor().extract(query="MSG",
body=buy_update_resp.text),
JMESPathExtractor().extract(query="STATUS",
body=buy_update_resp.text)
]
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,
order_id=buy_order_id)
buy_order_status = ConnectMysql(_type=mysql_type).get_Order_Status(
order_id=buy_order_id, order_type=1)
logger.info("撤单后买单状态：{0}".format(buy_order_status))
balance_dict = {
"before_buy_main_balance": before_buy_main,
"before_buy_target_balance": before_buy_target,
"before_sell_main_balance": before_sell_main,
"before_sell_target_balance": before_sell_target,
"after_buy_main_balance": after_buy_main,
"after_buy_target_balance": after_buy_target,
"after_sell_main_balance": after_sell_main,
"after_sell_target_balance": after_sell_target,
}
logger.info("交易前买家主币余额：{0}--------交易后买家主币余额：{1}".format(
before_buy_main, after_buy_main))
logger.info("交易前买家目标币余额：{0}--------交易后买家目标币余额：{1}".format(
before_buy_target, after_buy_target))
self.assertListEqual(buy_assert_list, ["SUCCESS", "0"])
self.assertEqual(int(before_buy_main), int(after_buy_main))
self.assertEqual(int(before_buy_target), int(after_buy_target))
def test_04(self):
"""
合约账户余额正好等于转出数量，验证合约账户余额、BB账户余额
:return:
"""
logger.info("用例编号：3-4---合约账户余额正好等于转出数量，验证合约账户余额、BB账户余额")
amount = random.randint(1, 1000) * 100000000
ConnectMysql(_type=mysql_type).sda_update_user_balance(
user_id=self.user_id, sda_id=sda_id, sda_balance=amount)
# 转出前查询合约账户余额
info_dict = account_info(user=self.buyer,
session=self.session,
sda_id=sda_id)
before_account_balance = info_dict["balance"]
# 转入前查询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))
withdraw_resp = self.session.post(url=base + sda_account_withdraw_url,
data=get_sda_account_withdraw_param(
sda_id=sda_id, amount=amount))
logger.info("转出接口：{0}----返回信息：{1}".format(sda_account_withdraw_url,
withdraw_resp.json()))
msg = JMESPathExtractor().extract(query="MSG", body=withdraw_resp.text)
status = JMESPathExtractor().extract(query="STATUS",
body=withdraw_resp.text)
sync_id = JMESPathExtractor().extract(query="syncLockKey",
body=withdraw_resp.text)
# 转出后查询合约账户余额
# time.sleep(0.5)
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(2)
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))
logger.info("转出数量：{}".format(amount))
bb_flag = assert_one(
int(before_currency_balance) + amount, int(after_currency_balance))
sda_flag = assert_one(
int(before_account_balance) - amount, int(after_account_balance))
self.assertListEqual([True, True], [bb_flag, sda_flag])
def test_01(self, transtion_id):
"""
循环100次下限价买单，撤单，检验撤单后余额、冻结金额
"""
for i in range(1):
with self.subTest():
logger.info("<<==========================================================================================================================>")
logger.info("编号：82--1--ID：{0}--------循环下限价买单、撤单100次检查用户余额、冻结金额".format(transtion_id))
buyer = Base(user=BUYER)
mySetUp(transtion_id=transtion_id, mysql_type=mysql_type,redis_type=redis_type,buyer=BUYER,seller=SELLER,balance_value=balance_value)
# ConnectRedis(_type=redis_type, db=5).clear_user_freezing_assets(user_id=buyer.user_id)
warnings.simplefilter("ignore", ResourceWarning)
before_buy_main_resp, before_buy_target_resp = buyer.query_user_main_target_balance(mysql_type, transtion_id)
before_buy_main_balance_value = JMESPathExtractor().extract(query="OBJECT.balanceValue", body=before_buy_main_resp.text)
before_buy_main_freezingAssets = JMESPathExtractor().extract(query="OBJECT.freezingAssets", body=before_buy_main_resp.text)
num_min, price_min = ConnectMysql(mysql_type).query_currency_min(transtion_id)
for k in range(100):
time.sleep(3)
logger.info("- - -- - -- - - -- - - -- - - - - - - - -- - - - - -- -- - - -- - - - - - -- - - -- - - - - - -- - - -- - -- -")
buy_price = random.randrange(int(price_min), int(price_min) * 999999, int(price_min))
buy_num = random.randrange(int(num_min), int(num_min) * 999999, int(num_min))
buy_order_text = buyer.OrderReservations(transtion_id=transtion_id, price=buy_price, num=buy_num, order_type=限价)
buy_order_id = JMESPathExtractor().extract(query="OBJECT.buyerOrderId", body=buy_order_text.text)
try:
buy_order_status = ConnectMysql(mysql_type).get_Order_Status(order_id=buy_order_id, order_type=买单)
logger.info("买单状态：{}".format(buy_order_status))
except Exception as E:
logger.info("连接数据库查询订单状态异常：{}".format(E))
time.sleep(3)
after_buy_main_resp, after_buy_target_resp = buyer.query_user_main_target_balance(mysql_type=mysql_type, transtion_id=transtion_id)
after_buy_main_balance = JMESPathExtractor().extract(query="OBJECT.balanceValue", body=after_buy_main_resp.text)
after_buy_main_freezingAssets = JMESPathExtractor().extract(query="OBJECT.freezingAssets",body=after_buy_main_resp.text)
z = '{:.8f}'.format(float(after_buy_main_freezingAssets))
k = '{:.8f}'.format(float(before_buy_main_freezingAssets))
logger.info(" 下买单前用户主币余额：{0}--------- 下买单后用户主币余额：{1}".format(before_buy_main_balance_value, after_buy_main_balance))
logger.info("下买单前用户主币冻结金额：{0}---------下买单后用户主币冻结金额：{1}".format(k, z))
time.sleep(3)
buyer.updateRevocationStatus(type=买单, orderId=buy_order_id)
# update_buy_order_status = ConnectMysql(mysql_type).get_Order_Status(order_id=buy_order_id, order_type=买单)
# logger.info("撤单后订单状态：{}".format(update_buy_order_status))
after_update_buy_main_resp, after_update_buy_target_resp = buyer.query_user_main_target_balance(mysql_type=mysql_type, transtion_id=transtion_id)
after_update_buy_main_balance = JMESPathExtractor().extract(query="OBJECT.balanceValue", body=after_update_buy_main_resp.text)
after_update_buy_main_freezingAssets = JMESPathExtractor().extract(query="OBJECT.freezingAssets",body=after_update_buy_main_resp.text)
x = '{:.8f}'.format(float(after_update_buy_main_freezingAssets))
logger.info("撤单后用户主币金额：{0}------------------撤单后用户主币冻结金额：{1}".format(after_update_buy_main_balance,x))
after_deal_buy_main_resp, after_deal_buy_resp = buyer.query_user_main_target_balance(mysql_type, transtion_id)
buyer.close()
after_buy_main_update_balance = JMESPathExtractor().extract(query="OBJECT.balanceValue", body=after_deal_buy_main_resp.text)
after_buy_main_update_freezingAssets = JMESPathExtractor().extract(query="OBJECT.freezingAssets", body=after_deal_buy_main_resp.text)
x = '{:.8f}'.format(float(before_buy_main_freezingAssets))
y = '{:.8f}'.format(float(after_buy_main_update_freezingAssets))
logger.info("循环下单撤单100次后主币余额：{0}------起始主币余额{1}".format(after_buy_main_update_balance, before_buy_main_balance_value))
logger.info("循环下单撤单100次后主币冻结金额：{0}--------起始冻结金额{1}".format(y, x))
self.assertEqual(int(before_buy_main_balance_value), int(after_buy_main_update_balance))
def tet_01(self, number, transtion_id, main_currency_id,
target_currency_id, buy_price, buy_num, sell_price, sell_num):
"""
编号：52-1
市商市价买单，，市商市价卖单，不成交
做市商不支持市价单，此用例跳过
"""
logger.info(
"<<==========================================================================================================================>"
)
logger.info("用户说明：编号：52-1-%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)
buy_price, sell_price, buy_num, sell_num = int(buy_price), int(
sell_price), int(buy_num), int(sell_num)
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)
test_buyer = Base(user=BUYER)
buy_order_id = test_buyer.OrderReservations(transtion_id=transtion_id,
price=buy_price,
num=buy_num,
order_type=1)
time.sleep(1)
test_seller = Base(user=SELLER)
sell_order_id = test_seller.SellOrder(transtion_id=transtion_id,
price=sell_price,
num=sell_num,
order_type=1)
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,
order_id=sell_order_id)
buy_order_status = ConnectMysql(_type=2).get_Order_Status(
order_id=buy_order_id, order_type=1)
sell_order_status = ConnectMysql(_type=2).get_Order_Status(
order_id=sell_order_id, order_type=2)
logger.info("交易后买单状态：{0}-----交易后卖单状态：{1}".format(
buy_order_status, sell_order_status))
balance_dict = {
"before_buy_main_balance": before_buy_main,
"before_buy_target_balance": before_buy_target,
"before_sell_main_balance": before_sell_main,
"before_sell_target_balance": before_sell_target,
"after_buy_main_balance": after_buy_main,
"after_buy_target_balance": after_buy_target,
"after_sell_main_balance": after_sell_main,
"after_sell_target_balance": after_sell_target,
}
logger.info("交易前买家主币余额：{0}--------交易后买家主币余额：{1}".format(
before_buy_main, after_buy_main))
logger.info("交易前买家目标币余额：{0}--------交易后买家目标币余额：{1}".format(
before_buy_target, after_buy_target))
logger.info("交易前卖家主币余额：{0}--------交易后卖家主币余额：{1}".format(
before_sell_main, after_sell_main))
logger.info("交易前卖家目标币余额：{0}--------交易后卖家目标币余额：{1}".format(
before_sell_target, after_sell_target))
self.assertEqual(int(before_buy_main), int(after_buy_main))
self.assertEqual(int(before_buy_target), int(after_buy_target))
self.assertEqual(int(before_sell_main), int(after_sell_main))
self.assertEqual(int(before_sell_target), int(after_sell_target))
def test_01(self, number, transtion_id, main_currency_id,
target_currency_id, buy_price, buy_num, sell_price, sell_num):
logger.info(
"<<==========================================================================================================================>"
)
logger.info("用例说明： 编号：10-1-%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))
buy_price, sell_price, buy_num, sell_num = int(buy_price), int(
sell_price), int(buy_num), int(sell_num)
for i in range(3):
with self.subTest():
ConnectMysql(_type=mysql_type).update_balance_value(
user_mail=BUYER,
currency_id=main_currency_id,
balance_value=9900000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(
user_mail=BUYER,
currency_id=target_currency_id,
balance_value=9900000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(
user_mail=SELLER,
currency_id=main_currency_id,
balance_value=9900000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(
user_mail=SELLER,
currency_id=target_currency_id,
balance_value=9900000000000000)
num_min, price_min = ConnectMysql(
_type=mysql_type).query_currency_min(
transtion_id=transtion_id)
random_price = random.randrange(int(price_min),
int(price_min) * 999999,
int(price_min))
random_num = random.randrange(int(num_min),
int(num_min) * 999999,
int(num_min))
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)
test_buyer = Base(user=BUYER)
buy_order_id = test_buyer.OrderReservations(
transtion_id=transtion_id,
price=random_price,
num=random_num,
order_type=0)
test_seller = Base(user=SELLER)
sell_order_id = test_seller.SellOrder(
transtion_id=transtion_id,
price=random_price,
num=random_num,
order_type=0)
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,
order_id=buy_order_id)
buy_order_status = ConnectMysql(
_type=mysql_type).get_Order_Status(order_id=buy_order_id,
order_type=1)
sell_order_status = ConnectMysql(
_type=mysql_type).get_Order_Status(order_id=sell_order_id,
order_type=2)
logger.info("交易后买单状态：{0}-----交易后卖单状态：{1}".format(
buy_order_status, sell_order_status))
balance_dict = {
"before_buy_main_balance": before_buy_main,
"before_buy_target_balance": before_buy_target,
"before_sell_main_balance": before_sell_main,
"before_sell_target_balance": before_sell_target,
"after_buy_main_balance": after_buy_main,
"after_buy_target_balance": after_buy_target,
"after_sell_main_balance": after_sell_main,
"after_sell_target_balance": after_sell_target,
}
flag_list = count_value_single(buy_price=random_price,
buy_num=random_num,
sell_price=random_price,
sell_num=random_num,
**balance_dict)
logger.info(
"<<==========================================================================================================================>"
)
self.assertNotIn(False, flag_list)
def test_01(self, number, transtion_id, main_currency_id,
target_currency_id, buy_price, buy_num, sell_price, sell_num):
"""
编号：58-1
限价买单，不收手续费，限价卖单，收取手续费,部分成交
"""
logger.info(
"<<==========================================================================================================================>"
)
logger.info("用例说明：编号：58-1-%s 限价买单，不收手续费，限价卖单，收取手续费,部分成交" % number)
logger.info("买家账号：{0}--------卖家账号：{1}".format(BUYER, SELLER))
logger.info("-----交易对ID：{0}-----主币ID：{1}-----目标币ID：{2}".format(
transtion_id, main_currency_id, transtion_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)
buy_price, sell_price, buy_num, sell_num = int(buy_price), int(
sell_price), int(buy_num), int(sell_num)
logger.info("买入价格：{0}----买入数量：{1}-----卖出价格：{2}-----卖出数量{3}".format(
buy_price, buy_num, sell_price, sell_num))
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)
test_buyer = Base(user=BUYER)
buy_order_id = test_buyer.OrderReservations(transtion_id=transtion_id,
price=buy_price,
num=buy_num,
order_type=0)
time.sleep(1)
test_seller = Base(user=SELLER)
sell_order_id = test_seller.SellOrder(transtion_id=transtion_id,
price=sell_price,
num=sell_num,
order_type=0)
test_buyer = Base(user=BUYER)
buy_update_resp = test_buyer.updateRevocationStatus(
type=1, orderId=buy_order_id)
buy_assert_list = [
JMESPathExtractor().extract(query="MSG",
body=buy_update_resp.text),
JMESPathExtractor().extract(query="STATUS",
body=buy_update_resp.text)
]
test_seller = Base(user=SELLER)
sell_update_resp = test_seller.updateRevocationStatus(
type=2, orderId=sell_order_id)
sell_assert_list = [
JMESPathExtractor().extract(query="MSG",
body=sell_update_resp.text),
JMESPathExtractor().extract(query="STATUS",
body=sell_update_resp.text)
]
time.sleep(3)
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,
order_id=buy_order_id)
buy_order_status = ConnectMysql(_type=mysql_type).get_Order_Status(
order_id=buy_order_id, order_type=1)
sell_order_status = ConnectMysql(_type=mysql_type).get_Order_Status(
order_id=sell_order_id, order_type=2)
logger.info("交易后买单状态：{0}-----交易后卖单状态：{1}".format(
buy_order_status, sell_order_status))
balance_dict = {
"before_buy_main_balance": before_buy_main,
"before_buy_target_balance": before_buy_target,
"before_sell_main_balance": before_sell_main,
"before_sell_target_balance": before_sell_target,
"after_buy_main_balance": after_buy_main,
"after_buy_target_balance": after_buy_target,
"after_sell_main_balance": after_sell_main,
"after_sell_target_balance": after_sell_target,
}
logger.info("交易前买家主币余额：{0}--------交易后买家主币余额：{1}".format(
before_buy_main, after_buy_main))
logger.info("交易前买家目标币余额：{0}--------交易后买家目标币余额：{1}".format(
before_buy_target, after_buy_target))
logger.info("交易前卖家主币余额：{0}--------交易后卖家主币余额：{1}".format(
before_sell_main, after_sell_main))
logger.info("交易前卖家目标币余额：{0}--------交易后卖家目标币余额：{1}".format(
before_sell_target, after_sell_target))
self.assertListEqual(buy_assert_list, ["SUCCESS", "0"])
self.assertListEqual(sell_assert_list, ["订单已被成交", "1"])
self.assertIn(
int(before_buy_main) - int(after_buy_main) -
int(buy_price * sell_num / 100000000), [0, 1])
self.assertIn(
int(after_buy_target) - int(before_buy_target) - int(sell_num),
[0, 1])
self.assertIn(
int(after_sell_main) - int(before_sell_main) -
int(buy_price * sell_num / 100000000 * (1 - 2 / 1000)), [0, 1])
self.assertIn(
int(before_sell_target) - int(after_sell_target) - int(sell_num),
[0, 1])
def test_01(self, number, transtion_id, main_currency_id, target_currency_id, buy_price, buy_num, sell_price, sell_num):
logger.info("<<==========================================================================================================================>")
logger.info("用例说明： 编号：81-1-%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))
buy_price, sell_price, buy_num, sell_num = int(buy_price), int(sell_price), int(buy_num), int(sell_num)
for i in range(2):
with self.subTest():
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=main_currency_id, balance_value=9900000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=target_currency_id, balance_value=9900000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=SELLER, currency_id=main_currency_id, balance_value=9900000000000000)
ConnectMysql(_type=mysql_type).update_balance_value(user_mail=SELLER, currency_id=target_currency_id, balance_value=9900000000000000)
random_price = random.randint(10, 999) * 100000000
random_num = random.randint(10, 99) * 100000000
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
)
test_buyer = Base(user=BUYER)
buy_order_id = test_buyer.OrderReservations(transtion_id=transtion_id, price=random_price, num=random_num, order_type=0)
time.sleep(1)
test_seller = Base(user=SELLER)
sell_order_id = test_seller.SellOrder(transtion_id=transtion_id, price=random_price, num=random_num, order_type=0)
time.sleep(3)
test_buyer = Base(user=BUYER)
buy_update_resp = test_buyer.updateRevocationStatus(type=1, orderId=buy_order_id)
buy_assert_list = [JMESPathExtractor().extract(query="MSG", body=buy_update_resp.text), JMESPathExtractor().extract(query="STATUS", body=buy_update_resp.text)]
test_seller = Base(user=SELLER)
sell_update_resp = test_seller.updateRevocationStatus(type=2, orderId=sell_order_id)
sell_assert_list = [JMESPathExtractor().extract(query="MSG", body=sell_update_resp.text), JMESPathExtractor().extract(query="STATUS", body=sell_update_resp.text)]
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,
order_id=buy_order_id
)
buy_order_status = ConnectMysql(_type=mysql_type).get_Order_Status(order_id=buy_order_id, order_type=1)
sell_order_status = ConnectMysql(_type=mysql_type).get_Order_Status(order_id=sell_order_id, order_type=2)
logger.info("交易后买单状态：{0}-----交易后卖单状态：{1}".format(buy_order_status, sell_order_status))
balance_dict = {
"before_buy_main_balance": before_buy_main,
"before_buy_target_balance": before_buy_target,
"before_sell_main_balance": before_sell_main,
"before_sell_target_balance": before_sell_target,
"after_buy_main_balance": after_buy_main,
"after_buy_target_balance": after_buy_target,
"after_sell_main_balance": after_sell_main,
"after_sell_target_balance": after_sell_target,
}
self.assertListEqual(buy_assert_list, ["订单已被成交", "1"])
self.assertListEqual(sell_assert_list, ["订单已被成交", "1"])
flag_list = count_value_single(buy_price=random_price, buy_num=random_num, sell_price=random_price, sell_num=random_num, **balance_dict)
logger.info("<<==========================================================================================================================>")
self.assertNotIn(False, flag_list)