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): """ 多单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_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): """ 持仓后验证持仓价值是否返回 :return: """ logger.info("用例编号:202-1,验证持仓价值和开仓价值计算") 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"]) buy_open_positions_value = open_positions_value( hold_price=self.deal_price, hold_num=self.deal_num, trade_unit=int(market_dict["tradeUnit"])) print("buy_open_positions_value", buy_open_positions_value) buy_positions_value = positions_value( stock_price=int(market_dict["stockPrice"]), hold_num=self.deal_num, trade_unit=int(market_dict["tradeUnit"])) print("buy_positions_value", buy_positions_value) flag = assert_list([ int(positions_dict["sdaValuation"]), int(positions_dict["sdaOpeningValuation"]) ], [int(buy_positions_value), int(buy_open_positions_value)]) self.assertEqual(flag, True)
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_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_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])
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): """ 限价空单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])