def test_05(self): """ 市价多单100倍杠杆委托,正常下单。 """ logger.info("用例编号:107-2---市价多单100倍杠杆委托,正常下单。") 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=市价, lever="100", 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_05(self): """ 市价多单,用户余额为0,验证下单是否成功。 :return: """ logger.info("用例编号:20-5----市价多单,用户余额为0,验证下单是否成功。") 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_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 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_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 test_01(self, number, transtion_id, main_currency_id, target_currency_id, buy_price, buy_num, sell_price, sell_num): logger.info("<<==========================================================================================================================>") logger.info("用例说明: 编号:90-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) # price_min, num_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) buy_balance_value_list = [buy_price*buy_num/100000000-1, 0] for i in buy_balance_value_list: with self.subTest(): ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=main_currency_id, balance_value=i) ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=target_currency_id, balance_value=9900000000000000) 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, buy_price, buy_num)) logger.info("下限价买单信息:{}".format(resp.json())) session.close() 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_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_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)
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): """ 编号: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_02(self): """ 连续下N个空单,连续撤单,验证订单状态、用户余额 """ logger.info("用例编号:109-2---连续下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=990000000000000) # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] price = int(int(now_stock_price) * 0.95) deal_num = 100000000 lever = 50 # 下委托前查询可用余额 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=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) try: 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())) # time.sleep(1) except Exception as E: logger.info("撤单次数:{0}---失败信息:{1}".format(i, E)) # 下委托后查询可用余额 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 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_06(self): """ 限价空单,循环下单,验证可用余额、委托保证金 :return: """ logger.info("用例编号:6-6---限价空单,循环下单,验证可用余额、委托保证金") sda_balance = 9999999900000000 ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id) ConnectRedis(_type=redis_type, db=4).sda_clear_user_balance(user_id=self.user_id, keys=sda_id) ConnectMysql(_type=mysql_type).sda_update_user_balance( user_id=self.user_id, sda_id=sda_id, sda_balance=sda_balance) # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] stock_unit = int(stock_price_dict["tradeUnit"]) 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"] # 下限价委托 amount_list = [] sync_flag_list = [] employ_balance_list = [] for i in range(50): amount = random.randint(1, 100) * 100000000 amount_list.append(amount) 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=amount, )) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=order_resp.text) sync_flag = sda_sync_lock(session=self.session, sync_id=sync_id) sync_flag_list.append(sync_flag) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, order_resp.json())) # time.sleep(0.1) employ_balance = employBalance(price=price, count=amount, unit=stock_unit, lever=1) employ_balance_list.append(employ_balance) # 查询下委托后的可用余额 # time.sleep(3) for v in sync_flag_list: if "OK" != v: raise SyncException("sync lock 异常") else: after_info_dict = account_info(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) + sum(employ_balance_list)) self.assertTrue(flag_one)
def test_02(self, number, transtion_id, main_currency_id, target_currency_id, buy_price, buy_num, sell_price, sell_num): """ 编号:56-2 市价买单,普通用户,撤单 """ logger.info( "<<==========================================================================================================================>" ) logger.info("用例说明:编号:56-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)) 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) test_buyer.updateRevocationStatus(orderId=buy_order_id, 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=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.assertEqual(int(before_buy_main), int(after_buy_main)) self.assertEqual(int(before_buy_target), int(after_buy_target))
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_02(self): """ 限价空单,下单数量小于可用余额数量,验证下单状态。 """ logger.info("用例编号:22-2---限价空单,下单数量小于可用余额数量,验证下单状态。") sda_balance = 9000000000000 num = sda_balance + 100000000 ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id) ConnectRedis(_type=redis_type, db=4).sda_clear_user_balance(user_id=self.user_id, keys=sda_id) ConnectMysql(_type=mysql_type).sda_update_user_balance( user_id=self.user_id, sda_id=sda_id, sda_balance=sda_balance) # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] price = int(int(now_stock_price) * 0.95) # 查询可用余额 info_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id) before_balance = info_dict["balance"] # 下限价委托 order_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=price, order_num=num, )) msg = JMESPathExtractor().extract(query="MSG", body=order_resp.text) status = JMESPathExtractor().extract(query="STATUS", body=order_resp.text) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=order_resp.text) # order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=order_resp.text) # 查询当前委托 # get_open_dict = query_order_get_open(user=self.buyer, session=self.session, order_id=order_id) # order_quantity = get_open_dict["orderQuantity"] # 委托数量 # order_price = get_open_dict["orderPrice"] # 委托价格 # order_status = get_open_dict["orderStatus"] # 委托状态 # 查询下委托后的可用余额 after_info_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_balance = after_info_dict["balance"] flag_one = assert_one(int(before_balance), int(after_balance)) flag_three = assert_list([200, "该订单将会触发您所持仓位的强平", "1"], [order_resp.status_code, msg, status]) self.assertListEqual([True, True], [flag_one, flag_three])
def test_01(self): """ 多单,验证合约状态、余额。 """ logger.info("用例编号:20-1---限价多单,验证合约、用户余额。") deal_price = 100000000 deal_num = 100000000 # 更新此合约ID下的所有合约状态为2 ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id) ConnectRedis(_type=redis_type, db=4).sda_clear_user_balance(user_id=self.user_id, keys=sda_id) ConnectMysql(_type=mysql_type).sda_update_user_balance( user_id=self.user_id, sda_id=sda_id, sda_balance=990000000000) # 查询当前合约的unit stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) # now_stock_price = int(stock_price_dict["stockPrice"]) stock_unit = int(stock_price_dict["tradeUnit"]) # print("now stock price", now_stock_price) # 下单前查询两个用户的余额 account_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id) buy_balance = account_dict["balance"] buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=order_type.多单, order_price_type=order_type.限价, order_price=deal_price, order_num=deal_num)) buy_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=buy_resp.text) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:多单--返回信息:{3}".format( self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json())) # 计算委托价值 stock_value = int( stockValue(price=deal_price, count=deal_num, unit=stock_unit)) print("stock_value", stock_value) # 查询当前委托 order_get_open_resp = self.session.post( url=base + sda_order_get_open_url, data=get_sda_order_get_open_param(sda_id=sda_id)) get_order_id = JMESPathExtractor().extract( query="LIST[0].orderId", body=order_get_open_resp.text) order_num = JMESPathExtractor().extract(query="LIST[0].orderQuantity", body=order_get_open_resp.text) order_price = JMESPathExtractor().extract( query="LIST[0].orderPrice", body=order_get_open_resp.text) total_price = int(JMESPathExtractor().extract( query="LIST[0].totalPrice", body=order_get_open_resp.text)) order_flag = assert_list( [buy_order_id, deal_price, deal_num], [get_order_id, int(order_price), int(order_num)]) total_price_flag = assert_one(stock_value, total_price) self.assertTrue(total_price_flag) self.assertTrue(order_flag) after_account_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_account_balance = after_account_dict["balance"] flag = assert_one(int(buy_balance), int(after_account_balance) + deal_num) self.assertTrue(flag)
def test_05(self): """ 限价多单,循环多次下单,验证可用余额 :return: """ logger.info("用例编号:6-5--限价多单,循环多次下单,验证可用余额") price = 100000000 sda_balance = 9999999900000000 # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] stock_unit = int(stock_price_dict["tradeUnit"]) 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, price=1000000000) before_balance = info_dict["balance"] # 下单前查询用户的余额 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)) # 下限价委托 amount_list = [] sync_flag_list = [] employ_balance_list = [] for i in range(200): amount = random.randint(1, 100) * 100000000 amount_list.append(amount) 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=amount)) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=order_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, order_resp.json())) sync_flag = sda_sync_lock(session=self.session, sync_id=sync_id) sync_flag_list.append(sync_flag) # time.sleep(0.1) # 计算每次下单所使用的保证金 employ_balance = employBalance(price=price, count=amount, unit=stock_unit, lever=1) employ_balance_list.append(employ_balance) # 查询下委托后的可用余额 # time.sleep(2) for v in sync_flag_list: if "OK" != v: raise SyncException("sync lock 异常") else: after_info_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id, price=1000000000) after_balance = after_info_dict["balance"] # 查询用户余额,然后判断下单前后的用户余额 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)) flag_one = assert_one(int(before_balance), int(after_balance) + sum(employ_balance_list)) # flag_two = assert_one(int(buy_entrust_value), int(after_buy_entrust_value) + sum(amount_list)) self.assertTrue(flag_one)
def test_02(self): """ 空单,验证合约状态、余额。 """ logger.info("用例编号:20-2---限价空单,验证合约状态、余额。") # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] price = int(int(now_stock_price) * 0.95) deal_num = 100000000 # 更新此合约ID下的所有合约状态为3 ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id) ConnectRedis(_type=redis_type, db=4).sda_clear_user_balance(user_id=self.user_id, keys=sda_id) ConnectMysql(_type=mysql_type).sda_update_user_balance( user_id=self.user_id, sda_id=sda_id, sda_balance=990000000000) # 下单前查询两个用户的余额 account_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id) buy_balance = account_dict["balance"] # 下空单 buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=order_type.空单, order_price_type=order_type.限价, order_price=price, order_num=deal_num)) buy_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=buy_resp.text) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json())) # 查询当前委托 order_get_open_resp = self.session.post( url=base + sda_order_get_open_url, data=get_sda_order_get_open_param(sda_id=sda_id, order_id=buy_order_id)) get_order_id = JMESPathExtractor().extract( query="LIST[0].orderId", body=order_get_open_resp.text) order_num = JMESPathExtractor().extract(query="LIST[0].orderQuantity", body=order_get_open_resp.text) order_price = JMESPathExtractor().extract( query="LIST[0].orderPrice", body=order_get_open_resp.text) # 查询用户余额,然后判断下单前后的用户余额 after_account_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_account_balance = after_account_dict["balance"] flag = assert_one( int(buy_balance), int(after_account_balance) + deal_num * price / 100000000) self.assertTrue(flag)
def test_08(self): """ 市价空单,循环下单,验证可用余额、委托保证金 """ sda_balance = 9999999900000000 logger.info("用例编号:6-8----时间空单,循环下单,验证可用余额、委托保证金") price = 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"] # 下单前查询用户的余额 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)) # 下市价价委托 sync_id = None amount_list = [] sync_flag_list = [] for i in range(500): amount = random.randint(1, 100) * 100000000 amount_list.append(amount) order_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=市价, order_num=amount, )) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=order_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, order_resp.json())) sync_flag = sda_sync_lock(session=self.session, sync_id=sync_id) sync_flag_list.append(sync_flag) # time.sleep(0.1) # 查询下委托后的可用余额 # time.sleep(1) for v in sync_flag_list: if "OK" != v: raise SyncException("sync lock 异常") else: after_info_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id, price=1000000000) after_balance = after_info_dict["balance"] # 查询用户余额,然后判断下单前后的用户余额 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)) flag_one = assert_one(int(before_balance), int(after_balance)) # flag_two = assert_one(int(buy_entrust_value), int(after_buy_entrust_value)) self.assertTrue(flag_one)
def test_01(self): """ 限价卖\限价买:while(余额足够){A创建卖单,B买入}, 部分成交 手续费 == 2/1000 B限价买单 UserB_BuyOrderPrice = 200,250,300,350,400 , UserB_BuyOrderNum = 1, 2, 3, 4, 5 A限价卖单等差递增 UserA_SellOrderPrice = 200,250,300,350,400 , UserA_SellOrderNum = 1, 2, 3, 4, 6 """ ConnectRedis(_type=redis_type).clear_redis( get_redis_name(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) ConnectMysql(_type=mysql_type).update_balance_value( user_mail=BUYER, currency_id=main_currency_id, balance_value=99000000000000) ConnectMysql(_type=mysql_type).update_balance_value( user_mail=BUYER, currency_id=target_currency_id, balance_value=99000000000000) ConnectMysql(_type=mysql_type).update_balance_value( user_mail=SELLER, currency_id=main_currency_id, balance_value=99000000000000) ConnectMysql(_type=mysql_type).update_balance_value( user_mail=SELLER, currency_id=target_currency_id, balance_value=99000000000000) logger.info( "<<==========================================================================================================================>" ) logger.info("测试用例说明:{}".format(TestCase.test_01.__doc__)) logger.info("买家账号:{0}--------卖家账号:{1}".format(BUYER, SELLER)) logger.info("-----交易对ID:{0}-----主币ID:{1}-----目标币ID:{2}".format( transtion_id, main_currency_id, target_currency_id)) 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) buy_order_id_list = [] sell_order_id_list = [] for i in range(len(buy_price)): # 下买单 test_buyer = Base(user=BUYER) buy_order_id = test_buyer.OrderReservations( transtion_id=transtion_id, price=buy_price[i], num=buy_num[i], order_type=0) buy_order_id_list.append(buy_order_id) for v in range(len(sell_price)): # 下卖单 test_seller = Base(user=SELLER) sell_order_id = test_seller.SellOrder(transtion_id=transtion_id, price=sell_price[v], num=sell_num[v], order_type=0) sell_order_id_list.append(sell_order_id) time.sleep(6) 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) time.sleep(3) for t in buy_order_id_list: test_buyer = Base(user=BUYER) test_buyer.updateRevocationStatus(type=1, orderId=t) for k in sell_order_id_list: test_seller = Base(user=SELLER) test_seller.updateRevocationStatus(type=2, orderId=k) buy_order_status_list = [] sell_order_status_list = [] for _id in buy_order_id_list: buy_order_status = ConnectMysql(_type=mysql_type).get_Order_Status( order_id=_id, order_type=1) buy_order_status_list.append(buy_order_status) for sell_id in sell_order_id_list: sell_order_status = ConnectMysql( _type=mysql_type).get_Order_Status(order_id=sell_id, order_type=2) sell_order_status_list.append(sell_order_status) logger.info("交易后买单状态:{0}-----交易后卖单状态:{1}".format( buy_order_status_list, sell_order_status_list)) 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)) buy_value, deal_num, sell_value, sell_num_value = count_value_buy_first( buy_price, buy_num, sell_price, sell_num) self.assertEqual( int(after_buy_main), int(int(before_buy_main) - int(buy_value / 100000000))) self.assertEqual( int(after_buy_target), int(before_buy_target) + int(deal_num * (1 - 2 / 1000))) self.assertEqual( int(after_sell_main), int(before_sell_main) + int(sell_value / 100000000 * (1 - 2 / 1000))) self.assertEqual(int(after_sell_target), int(before_sell_target) - int(sell_num_value))
def test_01(self, number, transtion_id, main_currency_id, target_currency_id, buy_price, buy_num, sell_price, sell_num): """ 编号:41-1 限价买单,收手续费,限价卖单不收取手续费 """ logger.info( "<<==========================================================================================================================>" ) logger.info("用例说明: 编号:41-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=99000000000000) ConnectMysql(_type=mysql_type).update_balance_value( user_mail=BUYER, currency_id=target_currency_id, balance_value=99000000000000) ConnectMysql(_type=mysql_type).update_balance_value( user_mail=SELLER, currency_id=main_currency_id, balance_value=99000000000000) ConnectMysql(_type=mysql_type).update_balance_value( user_mail=SELLER, currency_id=target_currency_id, balance_value=99000000000000) 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) for i in range(10): 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_seller = Base(user=SELLER) time.sleep(1) 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))
def test_01(self): """ 限价多单委托,正常下单。 """ logger.info("用例编号:6-1---限价多单委托,正常下单。") price = 100000000 num = 100000000 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = int(stock_price_dict["stockPrice"]) stock_unit = int(stock_price_dict["tradeUnit"]) ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order( user_id=self.user_id, contract_id=sda_id, status=2) ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id) ConnectRedis(_type=redis_type, db=4).sda_clear_user_balance(user_id=self.user_id, keys=sda_id) ConnectMysql(_type=mysql_type).sda_update_user_balance( user_id=self.user_id, sda_id=sda_id, sda_balance=990000000000) # 查询可用余额 info_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id, price=1000000000) before_balance = info_dict["balance"] # 下限价委托 order_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=price, order_num=num, )) logger.info("下单:{}".format(order_resp.text)) msg = JMESPathExtractor().extract(query="MSG", body=order_resp.text) status = JMESPathExtractor().extract(query="STATUS", body=order_resp.text) order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=order_resp.text) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=order_resp.text) # 查询当前委托 # time.sleep(1) get_open_dict = query_order_get_open(user=self.buyer, session=self.session, order_id=order_id) order_quantity = get_open_dict["orderQuantity"] # 委托数量 order_price = get_open_dict["orderPrice"] # 委托价格 order_status = get_open_dict["orderStatus"] # 委托状态 # 查询下委托后的可用余额 time.sleep(5) after_info_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id, price=1000000000) after_balance = after_info_dict["balance"] employ_balance = employBalance(price=price, count=num, unit=stock_unit, lever=1) flag_one = assert_one(int(before_balance), int(after_balance) + int(employ_balance)) flag_two = assert_list( [int(order_quantity), int(order_price), order_status], [num, price, "0"]) flag_three = assert_list([200, "SUCCESS", "0"], [order_resp.status_code, msg, status]) self.assertListEqual([True, True, True], [flag_one, flag_two, flag_three])
def test_01(self, transtion_id): """ 先下限价买单,再下限价卖单,部分成交,检验冻结余额 """ logger.info("用例编号:84-1--%s----先下限价买单,再下限价卖单,部分成交,检验冻结余额" % transtion_id) main_currency_id, target_currency_id = ConnectMysql( _type=mysql_type).query_main_target_currency( transtion_id=transtion_id) ConnectRedis(_type=redis_type).clear_user_freezing_assets( user_id=self.buy_user_id, currency_id=main_currency_id) ConnectRedis(_type=redis_type).clear_user_freezing_assets( user_id=self.sell_user_id, currency_id=target_currency_id) ConnectMysql(_type=mysql_type).update_order_status( transtion_id=transtion_id, order_type=买单, order_status=1) ConnectMysql(_type=mysql_type).update_order_status( transtion_id=transtion_id, order_type=卖单, order_status=1) time.sleep(0.1) num_min, price_min = ConnectMysql(_type=mysql_type).query_currency_min( transtion_id=transtion_id) random_num = random.randrange(int(num_min), int(num_min) * 9999999, int(num_min)) random_price = random.randrange(int(price_min), int(price_min) * 9999999, int(price_min)) sell_random_num = random.randrange(int(num_min), int(num_min) * 9999999, int(num_min)) 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) logger.info("交易对:{0}-------主币:{1}-----目标币:{2}".format( transtion_id, main_currency_id, target_currency_id)) buy_main_resp = self.session.post(base + get_user_balance_servlet_url, data=get_user_balance_servlet_param( user=BUYER, currency_id=main_currency_id)) before_buy_main_freezing_value = JMESPathExtractor().extract( query="OBJECT.freezingAssets", body=buy_main_resp.text) buy_target_resp = self.session.post( url=base + get_user_balance_servlet_url, data=get_user_balance_servlet_param( user=BUYER, currency_id=target_currency_id)) before_buy_target_freezing_value = JMESPathExtractor().extract( query="OBJECT.freezingAssets", body=buy_target_resp.text) before_buy_main_balance_value = JMESPathExtractor().extract( query="OBJECT.balanceValue", body=buy_main_resp.text) before_x = transform_freezing_assets(before_buy_main_freezing_value) before_y = transform_freezing_assets(before_buy_target_freezing_value) sell_main_resp = self.sell_session.post( url=base + get_user_balance_servlet_url, data=get_user_balance_servlet_param( user=SELLER, currency_id=target_currency_id)) before_sell_main_freezing_value = JMESPathExtractor().extract( query="OBJECT.freezingAssets", body=sell_main_resp.text) sell_target_resp = self.sell_session.post( url=base + get_user_balance_servlet_url, data=get_user_balance_servlet_param( user=SELLER, currency_id=target_currency_id)) before_sell_target_freezing_value = JMESPathExtractor().extract( query="OBJECT.freezingAssets", body=sell_target_resp.text) before_a = transform_freezing_assets(before_sell_main_freezing_value) before_b = transform_freezing_assets(before_sell_target_freezing_value) before_sell_target_balance_value = JMESPathExtractor().extract( query="OBJECT.balanceValue", body=sell_target_resp.text) logger.info( "用户:{0}----下单前币:{1}--冻结金额:{2}-----下单前币:{3}---冻结金额:{4}".format( BUYER, main_currency_id, before_x, target_currency_id, before_y)) logger.info( "用户:{0}----下单前币:{1}--冻结金额:{2}-----下单前币:{3}---冻结金额:{4}".format( SELLER, main_currency_id, before_a, target_currency_id, before_b)) logger.info("用户:{0}----下单前币:{1}--余额:{2}".format( BUYER, main_currency_id, before_buy_main_balance_value)) logger.info("用户:{0}----下单前币:{1}--余额:{2}".format( SELLER, target_currency_id, before_sell_target_balance_value)) buy_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)) logger.info("URL:{0}-----访问状态:{1}".format(order_reservations_url, buy_resp.status_code)) buy_status = JMESPathExtractor().extract(query="MSG", body=buy_resp.text) logger.info("下限价买单状态:{0}-----下单价格:{1}---------下单数量:{2}".format( buy_status, random_price, random_num)) logger.info("买单返回信息:{}".format(buy_resp.json())) time.sleep(3) sell_resp = self.sell_session.post(url=base + sell_order_url, data=get_sell_order_param( transtion_id=transtion_id, order_type=限价, price=random_price, num=sell_random_num)) logger.info("URL:{0}-----访问状态:{1}".format(sell_order_url, sell_resp.status_code)) sell_status = JMESPathExtractor().extract(query="MSG", body=sell_resp.text) logger.info("下限价卖单状态:{0}-----下单价格:{1}-------下单数量:{2}".format( sell_status, random_price, sell_random_num)) logger.info("卖单返回信息:{}".format(sell_resp.json())) time.sleep(1) after_buy_main = self.session.post( url=base + get_user_balance_servlet_url, data=get_user_balance_servlet_param(user=BUYER, currency_id=main_currency_id)) after_buy_main_freezing_value = JMESPathExtractor().extract( query="OBJECT.freezingAssets", body=after_buy_main.text) after_buy_target = self.session.post( url=base + get_user_balance_servlet_url, data=get_user_balance_servlet_param( user=BUYER, currency_id=target_currency_id)) after_buy_target_freezing_value = JMESPathExtractor().extract( query="OBJECT.freezingAssets", body=after_buy_target.text) after_x = transform_freezing_assets(after_buy_main_freezing_value) after_y = transform_freezing_assets(after_buy_target_freezing_value) after_sell_main = self.sell_session.post( url=base + get_user_balance_servlet_url, data=get_user_balance_servlet_param(user=SELLER, currency_id=main_currency_id)) after_sell_main_freezing_value = JMESPathExtractor().extract( query="OBJECT.freezingAssets", body=after_sell_main.text) after_sell_target = self.sell_session.post( url=base + get_user_balance_servlet_url, data=get_user_balance_servlet_param( user=SELLER, currency_id=target_currency_id)) after_sell_target_freezing_value = JMESPathExtractor().extract( query="OBJECT.freezingAssets", body=after_sell_target.text) after_a = transform_freezing_assets(after_sell_main_freezing_value) after_b = transform_freezing_assets(after_sell_target_freezing_value) after_buy_main_balance_value = JMESPathExtractor().extract( query="OBJECT.balanceValue", body=after_buy_main.text) after_sell_target_balance_value = JMESPathExtractor().extract( query="OBJECT.balanceValue", body=after_sell_target.text) print(BUYER, after_x, after_y) print(SELLER, after_a, after_b) logger.info( "用户:{0}----下单后币:{1}--冻结金额:{2}----下单后币:{3}--冻结金额:{4}".format( BUYER, main_currency_id, after_x, target_currency_id, after_y)) logger.info( "用户:{0}----下单后币:{1}--冻结金额:{2}----下单后币:{3}--冻结金额:{4}".format( SELLER, main_currency_id, after_a, target_currency_id, after_b)) logger.info("用户:{0}----下单后币:{1}---余额:{2}".format( BUYER, main_currency_id, after_buy_main_balance_value)) logger.info("用户:{0}----下单后币:{1}---余额:{2}".format( SELLER, target_currency_id, after_sell_target_balance_value)) if random_num > sell_random_num: self.assertEqual( int((random_num - sell_random_num) * random_price / 100000000), after_x) self.assertEqual( int(before_buy_main_balance_value), int(after_buy_main_balance_value) - int(random_price * random_num / 100000000)) elif random_num < sell_random_num: self.assertEqual(int(sell_random_num - random_num), after_b) self.assertEqual( int(before_sell_target_balance_value), int(after_sell_target_balance_value) + sell_random_num)
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("用例说明: 编号:91-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)) num_min, price_min = ConnectMysql(_type=mysql_type).query_currency_min( transtion_id=transtion_id) logger.info( "transtion_id : {0}-----price_min : {1}------num_min : {2}----buy_price : {3}" .format(transtion_id, price_min, num_min, int(price_min) - 1)) 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=9900000000000000) 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, int(price_min) - 1, buy_num)) 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] self.assertIn(int(before_buy_main) - int(after_buy_main), [0, 1]) self.assertIn(int(before_buy_target) - int(after_buy_target), [0, 1]) self.assertListEqual(assert_list, ["最小交易单位不对", "1"])
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): """ 下买卖单,达不到成交价格,循环撤单,验证余额 """ ConnectRedis(_type=redis_type).clear_redis(name=get_redis_name( transtion_id=transtion_id)) ConnectMysql(_type=mysql_type).update_order_status( transtion_id=transtion_id, order_type=1, order_status=2) ConnectMysql(_type=mysql_type).update_order_status( transtion_id=transtion_id, order_type=2, order_status=2) logger.info( "<<==========================================================================================================================>" ) logger.info("测试用例说明:".format(TestCase.test_01.__doc__)) logger.info("买家账号:{0}--------卖家账号:{1}".format(BUYER, SELLER)) logger.info("-----交易对ID:{0}-----主币ID:{1}-----目标币ID:{2}".format( transtion_id, main_currency_id, target_currency_id)) # 下单前查询买卖双发的主币和目标币余额 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) logger.info("成交之前买家主币余额:{0}-----成交之前买家目标币余额:{1}".format( before_buy_main, before_buy_target)) logger.info("成交之前卖家的主币余额:{0}------成交之前卖家的目标币余额{1}".format( before_sell_main, before_sell_target)) logger.info("买入价格:{0}-----买入数量{1}".format(buy_price, buy_num)) logger.info("卖出价格:{0}-----卖出数量{1}".format(sell_price, sell_num)) self.buy_id_list = [] # 下一个买单 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_seller = Base(user=SELLER) sell_order_id = test_seller.SellOrder(transtion_id=transtion_id, price=sell_price, num=sell_num, order_type=0) time.sleep(5) for i in range(10): test_buyer.updateRevocationStatus(type=1, orderId=buy_order_id) time.sleep(5) test_seller.updateRevocationStatus(type=2, orderId=sell_order_id) 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) 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.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))