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_02(self): """ 限价空单持仓成功,下空单委托 """ logger.info("用例编号:32-2---空单持仓成功,下限价空单委托,下限价多单成交,验证余额,委托状态") range_num = 10 sell_num = 100000000 buy_num = sell_num * range_num # 查询当前股价 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.seller, session=self.sell_session, sda_id=sda_id, price=1000000000) before_balance = info_dict["balance"] # 下空单委托 for i in range(range_num): sell_order_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)) # time.sleep(0.1) logger.info("接口:{0}----返回信息:{1}".format(sda_order_create_url, sell_order_resp.json())) buy_order_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)) logger.info("接口:{0}---返回信息:{1}".format(sda_order_create_url, buy_order_resp.json())) sync_id = JMESPathExtractor().extract(query="syncLockKey", body=buy_order_resp.text) # 下委托后查询可用余额 # time.sleep(1) after_info_dict = account_info_sync(sync_id=sync_id, user=self.seller, session=self.sell_session, sda_id=sda_id, price=1000000000) after_balance = after_info_dict["balance"] flag = assert_one(int(before_balance), int(after_balance) + buy_num * price / 100000000) self.assertTrue(flag)
def test_01(self, lever, lever_two): """ 多单1单,空单1单,多单完全成交,空单部分成交,验证合约状态、用户余额 """ logger.info("用例编号:114-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"] 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())) # 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=限价, 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(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_01(self): """ 参数化测试不同手续费和资金费率 :return: """ lever = 10 logger.info("用例编号:130-1---参数化测试不同开仓手续费和资金费率") deal_num = 100000000 warnings.simplefilter("ignore", ResourceWarning) for i in range(50): charge = int(random.uniform(0.01, 0.99) * 100) / 100 cost = int(random.uniform(0.01, 0.99) * 100) / 100 # print("charge", charge) # print("cost", cost) # 更新用户开仓手续费和资金费率 ConnectMysql(_type=mysql_type).update_user_charge( user_mail=self.buyer, sda_id=sda_id, charge=charge, cost=cost) # 查询当前股价 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"]) # 下一单多单、空单,完全成交 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())) time.sleep(1) # 第三个用户下多单 three_resp = self.three_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.three_user, sda_order_create_url, three_resp.status_code, three_resp.json())) # 买方做平多单于多单成交 close_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, close_buy_resp.status_code, close_buy_resp.json())) sync_key = JMESPathExtractor().extract(query="syncLockKey", body=close_buy_resp.text) buy_info_resp = account_info_sync(user=self.buyer, session=self.session, sda_id=sda_id, sync_id=sync_key) after_buy_balance = int(buy_info_resp["balance"]) buy_open_cost = openStockCost(price=deal_price, count=deal_num, stockPrice=now_stock_price, doMore=True, unit=stock_unit) buy_close_cost = openStockCost(price=deal_price, count=deal_num, stockPrice=now_stock_price, doMore=False, unit=stock_unit) # print("after buy balance :", after_buy_balance) assert before_buy_balance, after_buy_balance + int(buy_open_cost + buy_close_cost)
def test_01(self): """ 多个限价多单、多个限价空单,验证订单状态、用户余额 """ logger.info("用例编号:46-1---多个限价多单、多个限价空单,验证订单状态、用户余额") deal_num = 100000000 random_num = 5 # 查询当前股价 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) # 下单前查询两个用户的可用余额 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"] before_sell_account_dict = account_info(user=self.seller, session=self.sell_session, sda_id=sda_id) before_sell_account_balance = before_sell_account_dict["balance"] buy_sync_id = None for i in range(random_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=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(1) sell_sync_id = None for v in range(random_num): # 循环下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=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(1) # time.sleep(2) # 下单结束后查询两个用户可用余额 after_buy_account_dict = account_info_sync(sync_id=buy_sync_id, user=self.buyer, session=self.session, sda_id=sda_id) after_buy_account_balance = after_buy_account_dict["balance"] after_sell_account_dict = account_info_sync(sync_id=sell_sync_id, user=self.seller, session=self.sell_session, sda_id=sda_id) after_sell_account_balance = after_sell_account_dict["balance"] buy_flag = assert_one( self.sda_balance, int(after_buy_account_balance) + int(random_num * deal_num * price / 100000000)) sell_flag = assert_one( self.sda_balance, int(after_sell_account_balance) + int(random_num * deal_num * price / 100000000)) self.assertListEqual([True, True], [buy_flag, sell_flag])
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_02(self): """ 限价空单1单,50倍杠杆,限价多单1单,1倍杠杆,完全成交,验证合约状态、用户余额 """ logger.info("用例编号:110-2---限价空单1单,50倍杠杆,限价多单1单,1倍杠杆,完全成交,验证合约状态、用户余额") deal_num = 200000000 lever = 50 # 查询当前股价 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) # 交易前查询用户余额 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 )) 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(1) # 查询当前持仓中买卖方持仓数量、保证金、开仓均价 after_buy_position_dict = query_account_position_get(sync_key=sell_sync_id, user=self.buyer, session=self.session) after_sell_position_dict = query_account_position_get(sync_key=sell_sync_id, 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 = (deal_num * deal_price / 100000000) / lever # sell_currency_balance = make_currency_balance(num=deal_num, price=deal_price) # 检验持仓均价,持仓量,保证金 balance_flag = assert_one(int(after_buy_currencyBalancePosition), int(buy_currency_balance)) self.assertTrue(balance_flag) 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_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): """ 空单,验证合约状态、余额。 """ 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_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_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_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_03(self): """ 限价空单1单,市价多单1单,多单部分成交,空单完全成交,验证合约状态、用户余额 """ logger.info("用例编号:45-3---限价空单1单,市价多单1单,多单部分成交,空单完全成交,验证合约状态、用户余额") sell_num = 100000000 buy_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"] 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=price, order_num=sell_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=price, order_num=buy_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 * price / 100000000), int(after_sell_balance)) buy_flag = assert_one( int(self.sda_balance - sell_num * price / 100000000), int(after_buy_balance)) self.assertListEqual([True, True], [sell_flag, buy_flag])
def test_01(self): """ 大数极限测试类 """ logger.info("用例编号:110-1---大数极限测试类") deal_num = 90000000000*100000000 lever = 100 # 查询当前股价 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) * 1) # deal_price = now_stock_price print("stock price", now_stock_price) 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() )) # time.sleep(5) # 查询当前持仓中买卖方持仓数量、保证金、开仓均价 after_buy_position_dict = query_account_position_get(sync_key=sell_sync_id, user=self.buyer, session=self.session) after_sell_position_dict = query_account_position_get(sync_key=sell_sync_id, 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 = employBalance(price=deal_price, count=deal_num, unit=stock_unit, lever=lever) # 检验持仓均价,持仓量,保证金 balance_flag = assert_one(int(after_buy_currencyBalancePosition), int(buy_currency_balance)) self.assertTrue(balance_flag) 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_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): """ 多单,验证合约状态、余额。 """ 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_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): """ 限价多单持仓成功,下限价多单委托,验证余额,委托状态 """ logger.info("用例编号:116-1---多单持仓成功,下限价多单50倍杠杆委托,下限价空单成交,验证余额,委托状态") range_num = 5 # price = 100000000 buy_num = 100000000 sell_num = buy_num * range_num lever = 50 # 查询当前股价 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) # 下委托前查询可用余额 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=限价, lever=lever, order_price=deal_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=限价, lever=lever, order_price=deal_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) + int(sell_num * deal_price / lever / 100000000)) self.assertTrue(flag)
def tes_02(self): """ 下单,平仓,记录金额和手续费,给代理商系统准备数据 :return: """ deal_num = 1000000000000 sell_num = 1000000000000 # 查询当前股价 stock_price_dict = market_info_get(user=self.buyer, session=self.session, sda_id=sda_id) now_stock_price = stock_price_dict["stockPrice"] unit = stock_price_dict["tradeUnit"] print(unit) # deal_price = int(int(now_stock_price) * 0.95) # 下一单多单、空单,完全成交,并平仓 profit_list = [] for i in range(10): 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=now_stock_price, order_num=deal_num)) # 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=now_stock_price, order_num=sell_num)) time.sleep(0.2) 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=now_stock_price, order_num=deal_num)) 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=now_stock_price, order_num=sell_num)) value = (int(now_stock_price) * deal_num / 100000000) / int(unit) # print("value ", value) profit = int(value * 0.002) profit_list.append(profit) # print("profit ", profit) print("list ", profit_list) print("sum list", sum(profit_list))
def test_01(self, lever): """ 参数化测试不同杠杆倍数成交,先限价多单,后限价空单 :return: """ logger.info("用例编号:111-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 = int(stock_price_dict["stockPrice"]) deal_price = int(int(now_stock_price) * 0.95) print("deal price", deal_price) # 下一单多单、空单,完全成交 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(1) # 查询当前持仓中买卖方持仓数量、保证金、开仓均价 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), 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])