def test_01(self): """ 多单持仓中,限价全平,多个对应委托,成交其中部分委托,验证委托状态、用户余额、手续费。 """ logger.info("用例编号:66--1---多单持仓中,限价全平,多个对应委托,成交其中部分委托,验证委托状态、用户余额、手续费。") range_num = 10 price = 20 * 100000000 buy_num = 10 * 100000000 sell_num = 2 * 100000000 time.sleep(0.5) buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平多, order_price_type=限价, order_price=price, order_num=buy_num)) buy_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_resp.text) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, buy_resp.json())) # time.sleep(1) sync_53_id = None for i in range(range_num): # 53用户下多单。 buy_53_resp = self.session_53.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=price, order_num=sell_num)) sync_53_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_53_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_53_resp.json())) # time.sleep(1) # time.sleep(3) after_53_info_dict = account_info_sync(sync_id=sync_53_id, user=self.user_53, session=self.session_53, sda_id=sda_id) after_53_account_balance = after_53_info_dict["balance"] after_info_dict = account_info_sync(sync_id=buy_sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_account_balance = after_info_dict["balance"] flag_51 = assert_one(int(after_account_balance), 10000001845965763) flag_53 = assert_one( self.sda_balance - int(price * sell_num * 10 / 100000000), int(after_53_account_balance)) self.assertListEqual([True, True], [flag_51, flag_53])
def test_01(self): """ 限价多单1单,限价空单1单,完全成交,验证合约状态、用户余额 """ logger.info("用例编号:40-1---限价多单N单,限价空单1单,完全成交,验证合约状态、用户余额") range_num = 100 deal_num = 100000000 buy_num = 1000*100000000 # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] deal_price = int(int(now_stock_price) * 0.95) # 下N个多单、空单,完全成交 for i in range(range_num): buy_resp = self.session.post(url=base+sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=deal_price,order_num=deal_num )) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:多单--返回信息:{3}".format( self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json() )) # time.sleep(0.2) # time.sleep(1) sell_resp = self.sell_session.post(url=base+sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=deal_price,order_num=buy_num )) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json() )) # time.sleep(10) # 查询当前持仓中买卖方持仓数量、保证金、开仓均价 after_buy_position_dict = query_account_position_get(user=self.buyer, session=self.session, sync_key=sell_sync_id) after_sell_position_dict = query_account_position_get(user=self.seller, session=self.sell_session, sync_key=sell_sync_id) after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"] after_buy_sdaCount = after_buy_position_dict["sdaCount"] after_buy_currencyBalancePosition = after_buy_position_dict["currencyBalancePosition"] after_sell_sdaAveragePrice = after_sell_position_dict["sdaAveragePrice"] after_sell_sdaCount = after_sell_position_dict["sdaCount"] after_sell_currencyBalancePosition = after_sell_position_dict["currencyBalancePosition"] # 计算保证金 # buy_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # 检验持仓均价,持仓量,保证金 price_flag = assert_one(int(deal_price), int(after_buy_sdaAveragePrice)) num_flag = assert_one(int(deal_num * range_num), int(after_buy_sdaCount)) # after_buy_flag = assert_one(buy_currency_balance, int(after_buy_currencyBalancePosition)) after_sell_flag = assert_list([int(deal_price), int(deal_num * range_num)], [int(after_sell_sdaAveragePrice), int(after_sell_sdaCount)]) self.assertListEqual([True, True, True], [price_flag, num_flag,after_sell_flag])
def test_04(self): """ 空单持仓中,部分限价平仓,验证持仓余额,平仓委托中状态,用户余额,手续费 :return: """ logger.info( "用例编号:51-4---空单持仓中,部分限价平仓,市价空单与平空成交,验证持仓余额,平仓委托中状态,用户余额,手续费") range_num = 10 price = 120 * 100000000 buy_num = 50 * 100000000 # 平空单 time.sleep(0.5) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平空, order_price_type=限价, order_price=price, order_num=buy_num)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, sell_resp.json())) # 53用户下多单。 # time.sleep(2) buy_53_resp = self.session_53.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=市价, order_price=price, order_num=buy_num)) sync_53_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_53_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_53_resp.json())) # time.sleep(3) after_53_info_dict = account_info_sync(sync_id=sync_53_id, user=self.user_53, session=self.session_53, sda_id=sda_id) after_53_account_balance = after_53_info_dict["balance"] after_info_dict = account_info_sync(sync_id=sell_sync_id, user=self.seller, session=self.sell_session, sda_id=sda_id) after_account_balance = after_info_dict["balance"] flag_51 = assert_one(int(after_account_balance), 9999386552015461) flag_53 = assert_one( self.sda_balance - int(price * buy_num / 100000000), int(after_53_account_balance)) self.assertListEqual([True, True], [flag_51, flag_53])
def test_02(self): """ 空单持仓,市价全平,多个对应委托,成交其中部分委托,验证委托状态、用户余额,手续费 """ logger.info("用例编号:67-2---空单持仓,市价全平,多个对应委托,成交其中部分委托,验证委托状态、用户余额,手续费") range_num = 10 price = 20 * 100000000 buy_num = 10 * 100000000 sell_num = 2 * 100000000 sync_53_id = None # time.sleep(0.5) for i in range(range_num): # 53用户下空单。 # time.sleep(1) buy_53_resp = self.session_53.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=price, order_num=sell_num)) sync_53_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_53_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_53_resp.json())) # time.sleep(3) # 平空单 sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平空, order_price_type=市价, order_num=0)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, sell_resp.json())) after_53_info_dict = account_info_sync(sync_id=sync_53_id, user=self.user_53, session=self.session_53, sda_id=sda_id) after_53_account_balance = after_53_info_dict["balance"] after_info_dict = account_info_sync(sync_id=sell_sync_id, user=self.seller, session=self.sell_session, sda_id=sda_id) after_account_balance = after_info_dict["balance"] flag_51 = assert_one(int(after_account_balance), 9999997802034236) flag_53 = assert_one( self.sda_balance - int(price * sell_num * range_num / 100000000), int(after_53_account_balance)) self.assertListEqual([True, True], [flag_51, flag_53])
def test_01(self): """ 限价空单1单,市价多单1单,多单完全成交,空单部分成交,验证合约状态、用户余额 """ logger.info("用例编号:45-1---限价空单1单,市价多单1单,多单完全成交,空单部分成交,验证合约状态、用户余额") deal_price = 100000000 sell_num = 100000000 buy_num = 200000000 # 下一单多单、空单,部分成交 buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=deal_price, order_num=buy_num)) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:多单--返回信息:{3}".format( self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json())) # time.sleep(3) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=市价, order_price=deal_price, order_num=sell_num)) sell_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=sell_resp.text) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json())) # time.sleep(2) info_dict = account_info_sync(sync_id=sync_id, user=self.seller, session=self.sell_session, sda_id=sda_id) after_sell_balance = info_dict["balance"] buy_info_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_buy_balance = buy_info_dict["balance"] # 计算保证金 # buy_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # 检验持仓均价,持仓量,保证金 sell_flag = assert_one(int(self.sda_balance - sell_num), int(after_sell_balance)) buy_flag = assert_one(int(self.sda_balance - buy_num), int(after_buy_balance)) self.assertListEqual([True, True], [sell_flag, buy_flag])
def test_01(self): """ 多单持仓中,部分市价平仓,有对应委托成交,部分成交,未成交部分自动撤单,验证用户余额、委托状态,手续费 """ logger.info("用例编号:63-1---多单持仓中,有对应委托成交,部分成交,未成交部分自动撤单,验证用户余额、委托状态,手续费") range_num = 10 price = 20 * 100000000 buy_num = 5 * 100000000 sell_num = 2 * 100000000 # 53用户下多单。 # time.sleep(2) buy_53_resp = self.session_53.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=price, order_num=sell_num)) sync_53_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_53_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_53_resp.json())) # 平多单 # time.sleep(2) buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平多, order_price_type=市价, order_price=price, order_num=0)) buy_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_resp.text) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, buy_resp.json())) # time.sleep(2) after_53_info_dict = account_info_sync(sync_id=sync_53_id, user=self.user_53, session=self.session_53, sda_id=sda_id) after_53_account_balance = after_53_info_dict["balance"] after_info_dict = account_info_sync(sync_id=buy_sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_account_balance = after_info_dict["balance"] flag_51 = assert_one(int(after_account_balance), 9999985889193153) flag_53 = assert_one( self.sda_balance - int(price * sell_num / 100000000), int(after_53_account_balance)) self.assertListEqual([True, True], [flag_51, flag_53])
def test_02(self): """ 空单持仓中,部分市价平仓,对应委托成交,部分成交,未成交部分自动撤单,验证用户余额,委托状态,手续费 """ logger.info( "用例编号:53-2---空单持仓中,部分市价平仓,对应委托成交,部分成交,未成交部分自动撤单,验证用户余额,委托状态,手续费") range_num = 10 price = 120 * 100000000 buy_num = 20 * 100000000 sell_num = 50 * 100000000 # 53用户下空单。 # time.sleep(2) buy_53_resp = self.session_53.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=price, order_num=buy_num)) sync_53_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_53_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_53_resp.json())) # 平空单 sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平空, order_price_type=市价, order_price=price, order_num=sell_num)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, sell_resp.json())) # time.sleep(3) after_53_info_dict = account_info_sync(sync_id=sync_53_id, user=self.user_53, session=self.session_53, sda_id=sda_id) after_53_account_balance = after_53_info_dict["balance"] after_info_dict = account_info_sync(sync_id=sell_sync_id, user=self.seller, session=self.sell_session, sda_id=sda_id) after_account_balance = after_info_dict["balance"] flag_51 = assert_one(int(after_account_balance), 9999154560806185) flag_53 = assert_one( self.sda_balance - int(price * buy_num / 100000000), int(after_53_account_balance)) self.assertListEqual([True, True], [flag_51, flag_53])
def test_04(self): """ 空单持仓,平空,与空单成交 """ logger.info("用例编号:50-4---空单持仓,平空,与空单成交") range_num = 10 price = 120 * 100000000 buy_num = 100 * 100000000 # 平空单 time.sleep(0.2) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平空, order_price_type=限价, order_price=price, order_num=buy_num)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, sell_resp.json())) # 53用户下空单。 # time.sleep(2) buy_53_resp = self.session_53.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=市价, order_num=buy_num)) sync_53_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_53_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_53_resp.json())) # time.sleep(3) after_53_info_dict = account_info_sync(sync_id=sync_53_id, user=self.user_53, session=self.session_53, sda_id=sda_id) after_53_account_balance = after_53_info_dict["balance"] after_info_dict = account_info_sync(sync_id=sell_sync_id, user=self.seller, session=self.sell_session, sda_id=sda_id) after_account_balance = after_info_dict["balance"] flag_balance = 9999773204030922 flag_51 = assert_one(int(after_account_balance), int(flag_balance)) flag_53 = assert_one( self.sda_balance - int(price * buy_num / 100000000), int(after_53_account_balance)) self.assertListEqual([True, True], [flag_51, flag_53])
def test_01(self): """ 多单1单,空单1单,多单完全成交,空单部分成交,验证合约状态、用户余额 """ logger.info("用例编号:41-1---限价多单1单,限价空单1单,多单完全成交,空单部分成交,验证合约状态、用户余额") deal_num = 100000000 sell_num = 200000000 # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] stock_unit = int(stock_price_dict["tradeUnit"]) deal_price = int(int(now_stock_price) * 0.95) # 下一单多单、空单,完全成交 buy_resp = self.session.post(url=base+sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=deal_price, order_num=deal_num )) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:多单--返回信息:{3}".format( self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json() )) # time.sleep(2) sell_resp = self.sell_session.post(url=base+sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=deal_price, order_num=sell_num )) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json() )) sell_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=sell_resp.text) # time.sleep(4) # 查询当前持仓中买卖方持仓数量、保证金、开仓均价 after_buy_position_dict = query_account_position_get(user=self.buyer, session=self.session, sync_key=sync_id) after_sell_position_dict = query_account_position_get(user=self.seller, session=self.sell_session, sync_key=sync_id) after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"] after_buy_sdaCount = after_buy_position_dict["sdaCount"] after_buy_currencyBalancePosition = int(after_buy_position_dict["currencyBalancePosition"]) after_sell_sdaAveragePrice = after_sell_position_dict["sdaAveragePrice"] after_sell_sdaCount = after_sell_position_dict["sdaCount"] after_sell_currencyBalancePosition = after_sell_position_dict["currencyBalancePosition"] # 计算保证金 buy_employ_balance = employBalance(price=deal_price, count=deal_num, unit=stock_unit, lever=1) print("buy_employ_balance", buy_employ_balance) print("after_buy") # 检验持仓均价,持仓量,保证金, price_flag = assert_one(int(deal_price), int(after_buy_sdaAveragePrice)) num_flag = assert_one(int(deal_num), int(after_buy_sdaCount)) after_buy_flag = assert_one(buy_employ_balance, after_buy_currencyBalancePosition) after_sell_flag = assert_list([int(deal_price), int(deal_num)], [int(after_sell_sdaAveragePrice), int(after_sell_sdaCount)]) self.assertListEqual([True, True, True, True], [after_buy_flag, price_flag, num_flag,after_sell_flag])
def test_01(self): """ 多单持仓中,部分限价平仓,验证持仓余额,平仓委托中状态,用户余额,手续费 """ logger.info("用例编号:61-1---多单持仓中,部分平仓,验证持仓余额,平仓委托中状态,用户余额,手续费") range_num = 10 price = 20 * 100000000 buy_num = 5 * 100000000 # 平多单 time.sleep(0.5) buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平多, order_price_type=限价, order_price=price, order_num=buy_num)) buy_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_resp.text) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, buy_resp.json())) # 53用户下多单。 # time.sleep(2) buy_53_resp = self.session_53.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=price, order_num=buy_num)) sync_53_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_53_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_53_resp.json())) # time.sleep(3) after_53_info_dict = account_info_sync(sync_id=sync_53_id, user=self.user_53, session=self.session_53, sda_id=sda_id) after_53_account_balance = after_53_info_dict["balance"] after_info_dict = account_info_sync(sync_id=buy_sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_account_balance = after_info_dict["balance"] flag_51 = assert_one(int(after_account_balance), 9999991872982882) flag_53 = assert_one( self.sda_balance - int(price * buy_num / 100000000), int(after_53_account_balance)) self.assertListEqual([True, True], [flag_51, flag_53])
def test_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_02(self): """ 验证股价波动后持仓价值变化 :return: """ logger.info("用例编号:202-2,验证股价波动后持仓价值变化") # 修改股价并重新计算用户持仓价值 after_stock_price = 22 set_stock_price(stock_price=after_stock_price) market_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) print("now stock price", market_dict["stockPrice"]) print("tradeUnit", market_dict["tradeUnit"]) positions_dict = query_account_position_get(user=self.buyer, session=self.session, sync_key=self.sync_key) # print(positions_dict) print("sdaValuation", positions_dict["sdaValuation"]) print("sdaOpeningValuation", positions_dict["sdaOpeningValuation"]) before_positions_value = positions_dict["sdaValuation"] # 股价波动 after_stock_price = 22 set_stock_price(stock_price=after_stock_price) # 股价波动后查询用户持仓价值 time.sleep(2) after_positions_dict = query_account_position_get( user=self.buyer, session=self.session, sync_key=self.sync_key) print("sdaValuation", after_positions_dict["sdaValuation"]) print("sdaOpeningValuation", after_positions_dict["sdaOpeningValuation"]) after_positions_value = positions_value( stock_price=after_stock_price * 100000000, hold_num=self.deal_num, trade_unit=int(market_dict["tradeUnit"])) after_open_positions_value = open_positions_value( hold_price=self.deal_price, hold_num=self.deal_num, trade_unit=int(market_dict["tradeUnit"])) positions_flag = assert_one(int(after_positions_value), int(after_positions_dict["sdaValuation"])) open_positions_value_flag = assert_one( int(after_open_positions_value), int(after_positions_dict["sdaOpeningValuation"])) self.assertListEqual([True, True], [positions_flag, open_positions_value_flag])
def test_01(self): """ 多单持仓中,部分市价平仓,无对应委托成交,自动撤单,验证用户余额、委托状态 """ logger.info("用例编号:62-1---多单持仓中,部分市价平仓,无对应委托成交,自动撤单,验证用户余额、委托状态") range_num = 10 price = 20*100000000 buy_num = 5*100000000 before_buy_account_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id) before_buy_account_balance = before_buy_account_dict["balance"] # 市价平多单 buy_resp = self.session.post(url=base+sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平多, order_price_type=市价, order_price=price, order_num=buy_num )) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_resp.text) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, buy_resp.json())) # time.sleep(2) after_buy_account_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_buy_account_balance = after_buy_account_dict["balance"] flag = assert_one(int(before_buy_account_balance), int(after_buy_account_balance)) self.assertTrue(flag)
def test_01(self): """ 转出清除赠金测试 :return: """ logger.info("用例编号:140-1----把用户转入的钱全部转出,赠金清除为0") balance = 30 * 100000000 sda_balance = 30 * 100000000 ConnectMysql(_type=mysql_type).sda_update_user_platform_freeze_balance( user_mail=self.buyer, sda_id=sda_id, balance=balance) # 更新可用余额 ConnectRedis(_type=redis_type, db=4).sda_clear_user_balance(user_id=self.user_id, keys=sda_id) ConnectMysql(_type=mysql_type).sda_clear_balance_value( user_id=self.user_id, sda_id=sda_id) ConnectMysql(_type=mysql_type).sda_update_user_balance( user_id=self.user_id, sda_id=sda_id, sda_balance=sda_balance) time.sleep(0.2) withdraw_dict = sda_account_withdraw(user=self.buyer, session=self.session, sda_id=sda_id, amount=balance) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=withdraw_dict.text) account_info_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id) flag = assert_one(int(account_info_dict["balance"]), 0) self.assertEqual(flag, True)
def test_01(self): """ 下限价多单单,下单数量大于可用余额 """ logger.info("用例编号: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_01(self): """ 限价多单持仓成功,下限价多单委托,验证余额,委托状态 """ logger.info("用例编号:32-1---多单持仓成功,下限价多单委托,下限价空单成交,验证余额,委托状态") range_num = 10 price = 100000000 buy_num = 100000000 sell_num = buy_num * range_num # 下委托前查询可用余额 info_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id, price=1000000000) before_balance = info_dict["balance"] for i in range(range_num): # 下限价委托 buy_order_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=price, order_num=buy_num, )) # time.sleep(0.1) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_order_resp.json())) sell_order_resp = self.session_54.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=price, order_num=sell_num)) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_order_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, sell_order_resp.json())) # 下委托后查询可用余额 # time.sleep(2) after_info_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id, price=1000000000) after_balance = after_info_dict["balance"] flag = assert_one(int(before_balance), int(after_balance) + sell_num) self.assertTrue(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 test_02(self): """ 限价空单委托,正常下单。 """ logger.info("用例编号:106-2----限价空单10倍杠杆委托,正常下单。") num = 1000000000 ConnectMysql(_type=mysql_type).sda_clear_open_empty_close_multi_order(user_id=self.user_id, contract_id=sda_id, status=2) ConnectMysql(_type=mysql_type).sda_clear_open_multi_close_open_order(user_id=self.user_id, contract_id=sda_id, status=2) ConnectRedis(_type=redis_type).sda_clear_order(sda_id=sda_id) ConnectRedis(_type=redis_type, db=4).sda_clear_user_balance(user_id=self.user_id, keys=sda_id) ConnectMysql(_type=mysql_type).sda_update_user_balance(user_id=self.user_id, sda_id=sda_id, sda_balance=990000000000) # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] price = int(int(now_stock_price) * 0.95) # 下委托前查询可用余额 info_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id, price=1000000000) before_balance = info_dict["balance"] # 下限价空单委托 order_resp = self.session.post(url=base+sda_order_create_url, data=get_sda_order_create_param(sda_id=sda_id, order_type=空单, order_price_type=限价, lever="10", order_price=price, order_num=num,)) msg = JMESPathExtractor().extract(query="MSG", body=order_resp.text) status = JMESPathExtractor().extract(query="STATUS", body=order_resp.text) order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=order_resp.text) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=order_resp.text) # 查询当前委托 # time.sleep(1) get_open_dict = query_order_get_open(user=self.buyer, session=self.session, order_id=order_id) order_quantity = get_open_dict["orderQuantity"] # 委托数量 order_price = get_open_dict["orderPrice"] # 委托价格 order_status = get_open_dict["orderStatus"] # 委托状态 # 查询委托后可用余额 after_info_dict = account_info_sync(sync_id=sync_id, user=self.buyer, session=self.session, sda_id=sda_id, price=1000000000) after_balance = after_info_dict["balance"] flag_one = assert_one(int(before_balance), int(after_balance) + int(price * num / 10 / 100000000)) flag_two = assert_list([int(order_quantity), int(order_price), order_status], [num, price, "0"]) flag_three = assert_list([200, "SUCCESS", "0"], [order_resp.status_code, msg, status]) self.assertListEqual([True, True, True], [flag_one, flag_two, flag_three])
def test_01(self): """ 下限价多单,撤单,验证用户余额,委托保证金余额 """ 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): """ 有委托的情况下禁止转出余额 :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_02(self): """ 有持仓,有平仓委托的情况下,可转出金额为0 :return: """ logger.info("用例编号:141-2--有持仓,有平仓委托的情况下,可转出金额为0") info_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = int(info_dict["stockPrice"]) buy_resp = 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=1 * 100000000) fund_dict = sda_fund_balance(user=self.buyer, session=self.session, sda_id=sda_id) flag = assert_one(int(fund_dict["withdrawMargin"]), 0) self.assertEqual(True, flag)
def test_01(self): """ 限价多单1单,杠杆5倍,限价空单1单,杠杆1倍,完全成交,验证合约状态、用户余额 """ logger.info( "用例编号:119-1---限价多单1单,杠杆50倍,限价空单1单,杠杆1倍,完全成交,验证保证金、开仓手续费、预估爆仓价") deal_num = 10 * 100000000 lever = 50 # 查询当前股价 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"]) deal_price = int(int(now_stock_price) * 0.95) # deal_price = 18*100000000 before_buy_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id) before_buy_balance = before_buy_dict["balance"] # 下一单多单、空单,完全成交 buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, lever=lever, order_price=deal_price, order_num=deal_num)) buy_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())) # time.sleep(3) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, lever=lever, order_price=deal_price, order_num=deal_num)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json())) # 计算仓位保证金 buy_employ_balance = employBalance(price=deal_price, count=deal_num, unit=stock_unit, lever=lever) print(buy_employ_balance) # 计算开仓手续费 open_stock_cost = openStockCost(price=deal_price, count=deal_num, doMore=True, unit=stock_unit, stockPrice=now_stock_price) # 计算未实现盈亏 buy_real_less = int( unRealLoss(holdAvgPrice=deal_price, count=deal_num, unit=stock_unit, doMore=True, holdCharge=open_stock_cost, stock_price=now_stock_price)) # 计算爆仓价 buy_crash_price = crashPrice(holdAvgPrice=deal_price, holdCount=deal_num, totalBalance=self.sda_balance - open_stock_cost, unit=stock_unit, doMore=True) time.sleep(0.1) buy_position_get_dict = query_account_position_get( user=self.buyer, session=self.session, sync_key=sell_sync_id) buy_bust_price = int(buy_position_get_dict["sdaBustPrice"]) # 预估爆仓价 buy_balance_position = int( buy_position_get_dict["currencyBalancePosition"]) # 仓位保证金 buy_unrealized_PNL = int( buy_position_get_dict["unrealizedPNL"]) # 未实现盈亏 balance_flag = assert_one(buy_balance_position, buy_employ_balance) # 检验保证金 bust_flag = assert_one(buy_bust_price, buy_crash_price) # 检验爆仓 pnl_flag = assert_one(buy_unrealized_PNL, buy_real_less) # 检验未实现盈亏 self.assertListEqual([True, True, True], [bust_flag, pnl_flag, balance_flag])
def test_01(self): """ 大数成交测试 :return: """ warnings.simplefilter("ignore", ResourceWarning) lever = 100 deal_num = 9999999900000 # 查询当前股价 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"]) deal_price = int(int(now_stock_price) * 0.95) # 下一单多单、空单,完全成交 buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, lever=lever, order_price=deal_price, order_num=deal_num)) buy_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())) # time.sleep(3) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, lever=lever, order_price=deal_price, order_num=deal_num)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json())) buy_info_dict = account_info_sync(user=self.buyer, session=self.session, sda_id=sda_id, sync_id=sell_sync_id) # print(buy_info_dict) after_buy_balance = int(buy_info_dict["balance"]) sell_info_dict = account_info_sync(user=self.seller, session=self.sell_session, sda_id=sda_id, sync_id=sell_sync_id) after_sell_balance = int(sell_info_dict["balance"]) # print("stock price", deal_price) # print("stock unit", stock_unit) # employ_balance = deal_price / 100000000 * deal_num # print("employ balance", employ_balance) employ_balance = int( employBalance(price=deal_price, count=deal_num, unit=stock_unit, lever=lever)) # print("employ balance", employ_balance) buy_flag = assert_one(after_buy_balance, int(self.sda_balance - employ_balance)) sell_flag = assert_one(after_sell_balance, int(self.sda_balance - employ_balance)) self.assertListEqual([True, True], [buy_flag, sell_flag])
def tet_04(self): """ 随机成交测试 :return: """ warnings.simplefilter("ignore", ResourceWarning) lever = 100 # deal_num = 100000000 # buy_num = 9*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"]) deal_price = int(int(now_stock_price) * 0.95) before_buy_info_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id) before_buy_balance = int(before_buy_info_dict["balance"]) print("before buy balance", before_buy_balance) before_sell_info_dict = account_info(user=self.seller, session=self.sell_session, sda_id=sda_id) before_sell_balance = int(before_sell_info_dict["balance"]) print("before sell balance", before_sell_balance) # random_price = random.randint(1, 99) * 100000000 random_num = random.randint(1, 999999) * 100000000 # 下一单多单、空单,完全成交 for i in range(1000): buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, lever=lever, order_price=now_stock_price, order_num=random_num)) # buy_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())) # time.sleep(3) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=市价, lever=lever, order_price=now_stock_price, order_num=random_num)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json())) buy_info_dict = account_info_sync(user=self.buyer, session=self.session, sda_id=sda_id, sync_id=sell_sync_id) # print(buy_info_dict) after_buy_balance = int(buy_info_dict["balance"]) sell_info_dict = account_info_sync(user=self.seller, session=self.sell_session, sda_id=sda_id, sync_id=sell_sync_id) after_sell_balance = int(sell_info_dict["balance"]) # print("stock price", deal_price) # print("stock unit", stock_unit) buy_employ_balance = int( employBalance(price=now_stock_price, count=random_num, unit=stock_unit, lever=lever)) employ_balance = int( employBalance(price=now_stock_price, count=random_num, unit=stock_unit, lever=lever)) print("buy employ balance", buy_employ_balance) buy_flag = assert_one(after_buy_balance, int(before_buy_balance - buy_employ_balance)) sell_flag = assert_one(after_sell_balance, int(before_sell_balance - employ_balance)) self.assertListEqual([True, True], [buy_flag, sell_flag]) # 平仓 time.sleep(0.1) buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平多, order_price_type=限价, lever=lever, order_price=now_stock_price, order_num=random_num)) # buy_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())) time.sleep(0.1) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平空, order_price_type=市价, lever=lever, order_price=now_stock_price, order_num=random_num)) # sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json()))
def test_01(self): """ 多单持仓,平仓,53用户下多单与之成交。 """ logger.info("用例编号:60-1---多单持仓,限价平仓,53用户下限价多单与之成交,验证持仓数据") range_num = 10 price = 20 * 100000000 buy_num = 12 * 100000000 first_num = 1 * 100000000 add_first_num = 3 * 100000000 add_first_price = 18 * 100000000 all_price = 20 * 100000000 # 平多单 time.sleep(3) buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平多, order_price_type=限价, order_price=price, order_num=first_num)) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, buy_resp.json())) # 53用户下多单。 # time.sleep(1) buy_53_resp = self.session_53.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=price, order_num=first_num)) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_53_resp.json())) # 第一次追仓 # time.sleep(2) first_add_buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=add_first_price, order_num=add_first_num)) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, first_add_buy_resp.json())) time.sleep(0.5) # 54用户下空单 resp_54 = self.session_54.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, order_price=add_first_price, order_num=add_first_num)) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, resp_54.json())) time.sleep(1) # 限价全平 second_buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=平多, order_price_type=限价, order_price=all_price, order_num=buy_num)) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, second_buy_resp.json())) # 53用户下单成交 second_sell_resp = self.session_53.post( url=base + sda_order_create_url, data=get_sda_order_create_param(sda_id=sda_id, order_type=多单, order_price_type=限价, order_price=all_price, order_num=buy_num)) second_sell_sync_id = JMESPathExtractor().extract( query="syncLockKey", body=second_sell_resp.text) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, second_sell_resp.json())) # time.sleep(3) after_53_info_dict = account_info_sync(sync_id=second_sell_sync_id, user=self.user_53, session=self.session_53, sda_id=sda_id) after_53_account_balance = after_53_info_dict["balance"] after_info_dict = account_info_sync(sync_id=second_sell_sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_account_balance = after_info_dict["balance"] flag_51 = assert_one(int(after_account_balance), 10000002429755492) self.assertTrue(flag_51)
def test_01(self): """ 限价多单1单,杠杆5倍,限价空单1单,杠杆1倍,完全成交,验证合约状态、用户余额 """ logger.info( "用例编号:120-1---限价多单1单,杠杆50倍,限价空单1单,杠杆1倍,完全成交,调整股价到爆仓价,引发多单爆仓,验证是否爆仓" ) deal_num = 10 * 100000000 lever = 50 # 查询当前股价 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) deal_price = int(now_stock_price * 0.95) # deal_price = 18*100000000 before_buy_dict = account_info(user=self.buyer, session=self.session, sda_id=sda_id) before_buy_balance = before_buy_dict["balance"] # 下一单多单、空单,完全成交 buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, lever=lever, order_price=deal_price, order_num=deal_num)) buy_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())) # time.sleep(3) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, lever=lever, order_price=deal_price, order_num=deal_num)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json())) # 计算开仓手续费 open_stock_cost = openStockCost(price=deal_price, count=deal_num, doMore=True, unit=stock_unit, stockPrice=now_stock_price) # 计算爆仓价 buy_crash_price = crashPrice(holdAvgPrice=deal_price, holdCount=deal_num, totalBalance=self.sda_balance - open_stock_cost, unit=stock_unit, doMore=True) print(buy_crash_price) # 调整股价低于多单爆仓价 set_stock_price(stock_price=int(buy_crash_price / 10000) / 10000) print("_buy_crash", int(buy_crash_price / 10000) / 10000) time.sleep(6) buy_history_dict = query_order_get_history(user=self.buyer, session=self.session) crash_status = buy_history_dict["orderStatus"] status_flag = assert_one("3", crash_status) self.assertTrue(status_flag)
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, lever): """ 参数化测试不同杠杆倍数成交,先限价多单,后市价空单 :return: """ logger.info( "用例编号:112-1---参数化测试不同杠杆倍数,5,10,20,50,100,成交,先限价多单,后市价空单,完全成交,验证余额") 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"] deal_price = int(int(now_stock_price) * 0.95) # 下一单多单、空单,完全成交 buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, lever=lever, order_price=deal_price, order_num=deal_num)) buy_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())) # time.sleep(3) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=市价, order_price=deal_price, order_num=deal_num)) sell_sync_id = JMESPathExtractor().extract(query="syncLockKey", body=sell_resp.text) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json())) time.sleep(4) # 查询当前持仓中买卖方持仓数量、保证金、开仓均价 after_buy_position_dict = query_account_position_get( user=self.buyer, session=self.session) after_sell_position_dict = query_account_position_get( user=self.seller, session=self.sell_session) after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"] after_buy_sdaCount = after_buy_position_dict["sdaCount"] after_buy_currencyBalancePosition = after_buy_position_dict[ "currencyBalancePosition"] after_sell_sdaAveragePrice = after_sell_position_dict[ "sdaAveragePrice"] after_sell_sdaCount = after_sell_position_dict["sdaCount"] after_sell_currencyBalancePosition = after_sell_position_dict[ "currencyBalancePosition"] # 计算保证金 # buy_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # 检验持仓均价,持仓量,保证金 price_flag = assert_one(int(deal_price), int(after_buy_sdaAveragePrice)) num_flag = assert_one(int(deal_num), int(after_buy_sdaCount)) # after_buy_flag = assert_one(buy_currency_balance, int(after_buy_currencyBalancePosition)) after_sell_flag = assert_list( [int(deal_price), int(deal_num)], [int(after_sell_sdaAveragePrice), int(after_sell_sdaCount)]) self.assertListEqual([True, True, True], [price_flag, num_flag, after_sell_flag])
def test_03(self, lever, lever_two): """ 多单1单,空单1单,多单部分成交,空单完全成交,验证合约状态、用户余额 """ logger.info("用例编号:114-3---限价多单1单,限价空单1单,多单部分成交,空单完全成交,验证合约状态、用户余额") deal_num = 200000000 sell_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"] deal_price = int(int(now_stock_price) * 0.95) # 下一单多单、空单,完全成交 buy_resp = self.session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=多单, order_price_type=限价, lever=lever, order_price=deal_price, order_num=deal_num)) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:多单--返回信息:{3}".format( self.buyer, sda_order_create_url, buy_resp.status_code, buy_resp.json())) buy_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=buy_resp.text) # time.sleep(1) sell_resp = self.sell_session.post(url=base + sda_order_create_url, data=get_sda_order_create_param( sda_id=sda_id, order_type=空单, order_price_type=限价, lever=lever_two, order_price=deal_price, order_num=sell_num)) logger.info("用户:{0}--接口:{1}--状态:{2}--类型:空单--返回信息:{3}".format( self.seller, sda_order_create_url, sell_resp.status_code, sell_resp.json())) sell_order_id = JMESPathExtractor().extract(query="OBJECT.orderId", body=sell_resp.text) # time.sleep(1) after_buy_balance = self.session.post( url=base + sda_account_asset_detail_get_url, data=get_sda_account_asset_detail_get_param()) after_sell_balance = self.sell_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_sell_balance_value = JMESPathExtractor().extract( query="OBJECT.PNLList[0].availableMargin", body=after_sell_balance.text) after_buy_entrust_value = JMESPathExtractor().extract( query="OBJECT.PNLList[0].entrustMargin", body=after_buy_balance.text) after_sell_entrust_value = JMESPathExtractor().extract( query="OBJECT.PNLList[0].entrustMargin", body=after_sell_balance.text) # 查询当前持仓中买卖方持仓数量、保证金、开仓均价 time.sleep(4) after_buy_position_dict = query_account_position_get( user=self.buyer, session=self.session) after_sell_position_dict = query_account_position_get( user=self.seller, session=self.sell_session) after_buy_sdaAveragePrice = after_buy_position_dict["sdaAveragePrice"] after_buy_sdaCount = after_buy_position_dict["sdaCount"] after_buy_currencyBalancePosition = after_buy_position_dict[ "currencyBalancePosition"] after_sell_sdaAveragePrice = after_sell_position_dict[ "sdaAveragePrice"] after_sell_sdaCount = after_sell_position_dict["sdaCount"] after_sell_currencyBalancePosition = after_sell_position_dict[ "currencyBalancePosition"] # 计算保证金 # buy_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # 检验持仓均价,持仓量,保证金 price_flag = assert_one(int(deal_price), int(after_buy_sdaAveragePrice)) num_flag = assert_one(int(sell_num), int(after_buy_sdaCount)) # after_buy_flag = assert_one(buy_currency_balance, int(after_buy_currencyBalancePosition)) after_sell_flag = assert_list( [int(deal_price), int(sell_num)], [int(after_sell_sdaAveragePrice), int(after_sell_sdaCount)]) self.assertListEqual([True, True, True], [price_flag, num_flag, after_sell_flag])