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)