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_04(self): """ 市价空单,可用余额小于下单数量,验证下单是否成功 """ logger.info("用例编号:20-4---市价空单,可用余额小于下单数量,验证下单是否成功") 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_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"] # 委托状态 # 查询下委托后的可用余额 # time.sleep(3) 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.assertTrue(flag_one)
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_02(self): """ 空单持仓,市价全平,多个对应委托,成交其中部分委托,验证委托状态、用户余额,手续费 """ logger.info("用例编号:58-2---空单持仓,市价全平,多个对应委托,成交其中部分委托,验证委托状态、用户余额,手续费") range_num = 10 price = 120 * 100000000 buy_num = 100 * 100000000 sell_num = 20 * 100000000 sync_53_id = None 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), 9999773204030922) 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_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_01(self): """ 多单持仓,市价全平,多个对应委托,成交其中部分委托,验证委托状态、用户余额、手续费 """ logger.info("用例编号:67-1----多单持仓,市价全平,多个对应委托,成交其中部分委托,验证委托状态、用户余额、手续费") range_num = 10 price = 20 * 100000000 buy_num = 10 * 100000000 sell_num = 2 * 100000000 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(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_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(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), 10000001845965764) 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): """ 多单持仓中,部分市价平仓,有对应委托成交,部分成交,未成交部分自动撤单,验证用户余额、委托状态,手续费 """ 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): """ 市价空单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_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_01(self): """ 正常访问 """ logger.info("用例编号:19-1---查询单个SDA合约账户信息接口,正常访问,验证接口状态、MSG、STATUS") info_resp = self.session.post(url=base+sda_account_info_url, data=get_sda_account_info_param(sda_id=sda_id)) msg = JMESPathExtractor().extract(query="MSG", body=info_resp.text) status = JMESPathExtractor().extract(query="STATUS", body=info_resp.text) logger.info("接口:{0}----接口状态:{1}----接口返回信息:{2}".format(sda_account_info_url, info_resp.status_code, info_resp.json())) self.assertListEqual([200, "SUCCESS", "0"], [info_resp.status_code, msg, status])
def test_01(self): """ 正常访问 """ logger.info("用例编号:201-1--查询首页接口测试,正常访问,验证接口状态、STATUS、MSG") positons_resp = self.session.post(url=base + home_page_url, data=home_page(version="1.3.2")) msg = JMESPathExtractor().extract(query="MSG", body=positons_resp.text) status = JMESPathExtractor().extract(query="STATUS", body=positons_resp.text) print(msg, status, positons_resp.status_code)
def test_01(self): """ 正常访问 """ logger.info("用例编号:9-1---查询历史委托接口,正常访问,验证接口状态、MSG、STATUS") history_resp = self.session.post(url=base+sda_order_get_history_url, data=get_sda_order_get_history_param(sda_id=sda_id)) msg = JMESPathExtractor().extract(query="MSG", body=history_resp.text) status = JMESPathExtractor().extract(query="STATUS", body=history_resp.text) logger.info("用户:{0}---接口:{1}--状态:{2}---返回信息:{3}".format(self.buyer, sda_order_get_history_url, history_resp.status_code, history_resp.json())) self.assertListEqual([200, "SUCCESS", "0"], [history_resp.status_code, msg, status])
def tet_05(self): """ 撤单接口,错误卖单ID撤单,验证接口返回状态、MSG、STATUS、OBJECT """ logger.info("用例编号:4-5---撤单接口,错误卖单ID撤单,验证接口返回状态、MSG、STATUS、OBJECT") update_resp = self.session.post(url=base+update_revocation_status_url, data=get_update_revocation_status_param(_type=卖单, order_id="sajd56")) status = JMESPathExtractor().extract(query="STATUS", body=update_resp.text) msg = JMESPathExtractor().extract(query="MSG", body=update_resp.text) OBJECT = JMESPathExtractor().extract(query="OBEJCT", body=update_resp.text) logger.info("用户:{0}----url:{1}-----接口状态:{2}".format(BUYER, update_revocation_status_url, update_resp.status_code)) logger.info("撤单返回信息:{}".format(update_resp.json())) self.assertListEqual([200, "订单不存在", "1"], [update_resp.status_code, msg, status])
def test_05(self): """ 查询当前委托接口,pageSize参数传超出长度,currentPage参数超出长度。验证接口返回状态、MSG、STATUS """ logger.info("用例编号:3-5---查询当前委托接口,languageType参数传超出长度,currentPage参数超出长度。验证接口返回状态、MSG、STATUS") resp = self.session.post(url=base+query_present_order_url, data=get_query_present_order_param(currentPage=10000, pageSize=15000)) status = JMESPathExtractor().extract(query="STATUS", body=resp.text) msg = JMESPathExtractor().extract(query="MSG", body=resp.text) OBJECT = JMESPathExtractor().extract(query="OBJECT", body=resp.text) logger.info("用户:{0}-----url:{1}-----接口状态:{2}".format(BUYER, query_present_order_url, resp.status_code)) logger.info("查询当前委托返回信息:{}".format(resp.json())) self.assertListEqual([200, "SUCCESS", None, "0"], [resp.status_code, msg, OBJECT, status])
def test_03(self): """ 查询当前委托接口,currencyPage传参:"",pageSize传参:"",验证接口返回状态、MSG、STATUS """ logger.info("用例编号:3-3----查询当前委托接口,currencyPage传参:"",验证接口返回状态、MSG、STATUS") resp = self.session.post(url=base+query_present_order_url, data=get_query_present_order_param(currentPage="",pageSize="")) status = JMESPathExtractor().extract(query="STATUS", body=resp.text) OBJECT = JMESPathExtractor().extract(query="OBJECT", body=resp.text) msg = JMESPathExtractor().extract(query="MSG", body=resp.text) logger.info("用户:{0}----url:{1}-----访问接口状态:{2}".format(BUYER, query_present_order_url, resp.status_code)) logger.info("查询当前委托返回信息:{}".format(resp.json())) self.assertListEqual([200, "SUCCESS", "0"], [resp.status_code, msg, status])
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 tearDown(self): logout_resp = self.session.post(url=base + logout_url, data=get_user_logout_param()) logout_status = JMESPathExtractor().extract(query="MSG", body=logout_resp.text) logger.info("用户:{0}-------退出状态:{1}".format(BUYER, logout_status)) self.session.close() sell_logout_resp = self.session.post(url=base + logout_url, data=get_user_logout_param()) sell_logout_status = JMESPathExtractor().extract( query="MSG", body=sell_logout_resp.text) logger.info("用户:{0}-------退出状态:{1}".format(SELLER, sell_logout_status)) self.sell_session.close()
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): """ 查询交易对接口,正常访问,验证接口状态、MSG、STATUS、OBJECT """ logger.info("用例编号:5-1---查询交易对接口,正常访问,验证接口状态、MSG、STATUS、OBJECT") resp = self.session.post(url=base + query_transtion_pari_url, data=get_query_transtion_pair_param()) logger.info("用户:{0}----URL:{1}-----接口状态:{2}".format( BUYER, query_transtion_pari_url, resp.status_code)) status = JMESPathExtractor().extract(query="STATUS", body=resp.text) msg = JMESPathExtractor().extract(query="MSG", body=resp.text) logger.info("查询交易对接口返回信息:{}".format(resp.json())) self.assertListEqual([200, "SUCCESS", "0"], [resp.status_code, msg, status])
def test_02(self, number, transtion_id, main_currency_id, target_currency_id, buy_price, buy_num, sell_price, sell_num): """ 余额刚好,下单成功 """ logger.info("<<==========================================================================================================================>") logger.info("用例说明: 编号:90-2-%s, 余额刚好下限价买单" % number) logger.info("买家账号:{0}--------卖家账号:{1}".format(BUYER, SELLER)) logger.info("-----交易对ID:{0}-----主币ID:{1}-----目标币ID:{2}".format(transtion_id, main_currency_id, target_currency_id)) ConnectMysql(_type=mysql_type).update_order_status(transtion_id=transtion_id, order_type=1, order_status=1) ConnectMysql(_type=mysql_type).update_order_status(transtion_id=transtion_id, order_type=2, order_status=1) ConnectRedis(_type=redis_type).clear_redis(get_redis_name(transtion_id)) """ ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=main_currency_id, balance_value=990000000000000) ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=target_currency_id, balance_value=990000000000000) ConnectMysql(_type=mysql_type).update_balance_value(user_mail=SELLER, currency_id=main_currency_id, balance_value=990000000000000) ConnectMysql(_type=mysql_type).update_balance_value(user_mail=SELLER, currency_id=target_currency_id, balance_value=990000000000000) """ num_min, price_min = ConnectMysql(_type=mysql_type).query_currency_min(transtion_id=transtion_id) value = int(num_min) * int(price_min) buy_price, sell_price, buy_num, sell_num = int(buy_price), int(sell_price), int(buy_num), int(sell_num) ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=main_currency_id, balance_value=value) ConnectMysql(_type=mysql_type).update_balance_value(user_mail=BUYER, currency_id=target_currency_id, balance_value=9900000000000000) before_buy_main, before_buy_target, before_sell_main, before_sell_target = query_user_balance_value( buyer=BUYER, seller=SELLER, main_currency_id=main_currency_id, target_currency_id=target_currency_id ) login_url = base_url + test_data.get("login_url") buy_url = base_url + test_data.get("order_reservations_url") session = requests.session() session.post(url=login_url, headers=login_header, data=get_login_param(user=BUYER, user_password=user_password)) resp = session.post(url=buy_url, data=get_order_reservations_param(transtion_id, 0, price=price_min, num=num_min)) logger.info("下单前买家主币余额:{0}-----下买单价格:{1}-----------下买单数量:{2}".format(before_buy_main, price_min, num_min)) session.close() logger.info("下买单返回信息:{}".format(resp.json())) after_buy_main, after_buy_target, after_sell_main, after_sell_target = query_user_balance_value( buyer=BUYER, seller=SELLER, main_currency_id=main_currency_id, target_currency_id=target_currency_id, transaction_id=transtion_id, ) assert_word = JMESPathExtractor().extract(query="MSG", body=resp.text) assert_status = JMESPathExtractor().extract(query="STATUS", body=resp.text) assert_list = [assert_word, assert_status] logger.info(" 下单前买家主币余额:{0}--------- 下单后买家主币余额:{1}-------成交金额{2}".format(before_buy_main, after_buy_main, math.ceil(value/100000000))) logger.info("下单前买家目标币余额:{0}---------下单后买家目标币余额:{1}".format(before_buy_target, after_buy_target)) self.assertIn(int(before_buy_main) - int(after_buy_main) - math.ceil(value/100000000), [0, 1]) self.assertIn(int(before_buy_target) - int(after_buy_target), [0, 1]) self.assertListEqual(assert_list, ["SUCCESS", "0"])
def test_01(self): """ 做市商撤销订单 """ self.sell_url = self.base_url + "/ordersellerrest.do" sell_data = { "sellerOrderNum": 10000000, "sellerOrderPrice": 500000, "languageType": 3, "timeStamp": "1538118050702", "transtionId": transtion_id, "userMail": "*****@*****.**", "userPass": "******" } self.sell_resp = self.requ.post(url=self.sell_url, data=sell_data) order_id = JMESPathExtractor().extract(query="OBJECT.sellerOrderId", body=self.sell_resp.text) time.sleep(4) data = { "userMail": "*****@*****.**", "userPass": "******", "orderId": order_id, "type": "2" } self.resp_3 = self.requ.post(url=self.url, data=data) print(self.resp_3.status_code) self.assertEqual(self.resp_3.json()["MSG"], "SUCCESS") print("撤单接口返回信息:", self.resp_3.json())
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_04(self): """ 正常提现 """ check_user_param = { "Email": "*****@*****.**", "Signature": "22e63226e0ae4111b6161a2bd1834721" } withdraw_param = { "Email": "*****@*****.**", "number": 3, "Signature": "ac0f5266e552fcff5b64d99d80ffdd31", } logger.info( "分割线----------------------------------------------------------------------------------------------------------------" ) logger.info("用户编号:29-4-----测试提现") resp = self.session.post(url=base_url + login_url, headers=headers, data=get_login_param(user=BUYER, user_password=password)) status = JMESPathExtractor().extract(query="MSG", body=resp.text) logger.info( "用户:{0}------登陆url:{1}-------接口返回状态:{2}-------登陆状态{3}".format( BUYER, login_url, resp.status_code, status)) check_user_resp = self.session.post(url=base_url + check_user_url, data=check_user_param) withdraw_resp = self.session.post(url=base_url + withdraw_url, data=withdraw_param) print(withdraw_resp.status_code) print(withdraw_resp.json())
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("用例编号:17-1---查询用户资金余额接口,正常访问,验证接口状态、MSG、STATUS") balance_resp = self.session.post(url=base + sda_fund_balance_url, data=get_sda_fund_balance_param()) logger.info("用户:{0}--接口:{1}--状态:{2}--返回信息:{3}".format( self.buyer, sda_fund_balance_url, balance_resp.status_code, balance_resp.json())) status = JMESPathExtractor().extract(query="STATUS", body=balance_resp.text) msg = JMESPathExtractor().extract(query="MSG", body=balance_resp.text) self.assertListEqual([200, "SUCCESS", "0"], [balance_resp.status_code, msg, status])
def test_01(self): """ 正常访问,验证接口状态、STATUS、MSG """ logger.info("用例编号:4-1----查询SDA列表信息,正常访问,验证接口状态、STATUS、MSG") list_resp = self.session.post(url=base + sda_get_list_url, data=get_sda_get_list_param()) logger.info("接口:{0}---状态:{1}--返回信息:{2}".format(sda_get_list_url, list_resp.status_code, list_resp.json())) msg = JMESPathExtractor().extract(query="MSG", body=list_resp.text) status = JMESPathExtractor().extract(query="STATUS", body=list_resp.text) self.assertListEqual([200, "0", "SUCCESS"], [list_resp.status_code, status, msg])
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_01(self): """ 正常访问 """ logger.info("用例编号:13-1---资金流水接口测试类,正常访问,验证接口状态、MSG、STATUS") fund_resp = self.session.post( url=base + query_sda_fund_record_url, data=get_sda_query_sda_fund_record_param()) msg = JMESPathExtractor().extract(query="MSG", body=fund_resp.text) status = JMESPathExtractor().extract(query="STATUS", body=fund_resp.text) logger.info("用户:{0}---接口:{1}--状态:{2}---返回信息:{3}".format( self.buyer, query_sda_fund_record_url, fund_resp.status_code, fund_resp.json())) self.assertListEqual([200, "SUCCESS", "0"], [fund_resp.status_code, msg, status])