def test_YW_GPMM_SHSJ_116(self):
title = '可用资金不足-沪A五档即成转撤销买（可用资金=下单金额+费用-0.01）'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': '废单',
'errorID': 11010120,
'errorMSG': queryOrderErrorMsg(11010120),
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('604006', '1', '0', '2', '0', 'B', case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type': Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':trade_type + 1,
'market': Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker': stkparm['证券代码'],
'side': Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'price_type': Api.const.XTP_PRICE_TYPE['XTP_PRICE_BEST5_OR_CANCEL'],
'price': stkparm['涨停价'],
'quantity': 200,
'position_effect': Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ','
+ str(rs['用例错误源']) + ',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True) # 4
def test_YW_ETFMM_SZSJ_369_D(self):
title = '可用资金正好-深A对方最优转限价卖（可用资金+卖出金额=费用）'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': ['全成','部成'][trade_type_allpart],
'errorID': 0,
'errorMSG': '',
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('157148', '2', '14', '2', '0', 'S', case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type': Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':trade_type_allpart + 2,
'market': Api.const.XTP_MARKET_TYPE['XTP_MKT_SZ_A'],
'ticker': stkparm['证券代码'],
'side': Api.const.XTP_SIDE_TYPE['XTP_SIDE_SELL'],
'price_type': Api.const.XTP_PRICE_TYPE['XTP_PRICE_REVERSE_BEST_LIMIT'],
'price': stkparm['涨停价'],
'quantity': 200,
'position_effect': Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ','
+ str(rs['用例错误源']) + ',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True) # 5
def test_YW_ETFMM_SZXJ_024_D(self):
title = '限价委托买-废单再撤单（OMS)'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': '废单',
'errorID': 11000343,
'errorMSG': queryOrderErrorMsg(11000343),
'是否生成报单': '是',
'是否是撤废': '是',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('999999', '2', '14', '2', '0', 'B', case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type': Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':5,
'market': Api.const.XTP_MARKET_TYPE['XTP_MKT_SZ_A'],
'ticker': stkparm['证券代码'],
'side': Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'price_type': Api.const.XTP_PRICE_TYPE['XTP_PRICE_LIMIT'],
'price': stkparm['随机中间价'],
'quantity': 200,
'position_effect': Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ','
+ str(rs['用例错误源']) + ',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True) # 5
def test_limit_SZa(self):
title = '深圳Ａ股股票限价买入全成测试'
#定义当前测试用例的期待值
#期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
#xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'case_ID': '111101',
'期望状态': '未成交',
'errorID': 0,
'errorMSG': '',
'是否生成报单': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title + ',case_ID=' + case_goal['case_ID'])
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('999999', '2', '0', '2', '0', 'B',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] == False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'market': Api.const.XTP_MARKET_TYPE['XTP_MKT_SZ_A'],
'ticker': stkparm['证券代码'],
'side': Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_FORWARD_BEST'],
'price': stkparm['随机中间价'],
'quantity': 200
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('用例执行结果' + str(rs['用例测试结果']) + ',' +
str(rs['用例错误源']) + ',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True)
def test_YW_GGQQ_YWFSJHA_GU_197(self):
title='卖开（义务方开仓）：FOK市价全成或撤销-不存在的证券代码'
#定义当前测试用例的期待值
#期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
#xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': '废单',
'errorID': 11000010,
'errorMSG': queryOrderErrorMsg(11000010),
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
wt_reqs = {
'business_type':Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_OPTION'],
'order_client_id':1,
'market': Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker': '10009999',
'side': Api.const.XTP_SIDE_TYPE['XTP_SIDE_SELL'],
'position_effect':Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_OPEN'],
'price_type': Api.const.XTP_PRICE_TYPE['XTP_PRICE_ALL_OR_CANCEL'],
'price': 1.0000,
'quantity': 2
}
ParmIni(Api,case_goal['期望状态'],wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
if rs['用例测试结果']:
logger.warning('执行结果为{0}'.format(str(rs['用例测试结果'])))
else:
logger.warning('执行结果为{0},{1},{2}'.format(
str(rs['用例测试结果']), str(rs['用例错误源']),
json.dumps(rs['用例错误原因'], encoding='UTF-8', ensure_ascii=False)))
self.assertEqual(rs['用例测试结果'], True) # 2
def test_YW_ETFMM_SZSJ_224_K(self):
title = '交易日全部成交或撤销-T+0买→T+0卖（已持有证券代码）'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
# 撤废:期望状态+是否是撤废=撤废类型。全成+是=oms全成后再撤单废单，未成交+是=交易所撤废，部撤+是=oms部撤后再撤单撤废，废单+是=废单后再撤废，已撤+是=oms已撤后再撤废
case_goal = {
'期望状态': '全成',
'errorID': 0,
'errorMSG': '',
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('158228', '2', '15', '2', '0', 'S',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
self.assertEqual(rs['用例测试结果'], True)
wt_reqs = {
'business_type':
Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':
2,
'market':
Api.const.XTP_MARKET_TYPE['XTP_MKT_SZ_A'],
'ticker':
stkparm['证券代码'],
'side':
Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_ALL_OR_CANCEL'],
'price':
stkparm['随机中间价'],
'quantity':
10000,
'position_effect':
Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
# T+0买
title = '深圳Ａ股交易日全部成交或撤销（已持有证券代码）-T+0买'
logger.warning(title)
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ',' + str(rs['用例错误源']) +
',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True)
# T+0卖
title = '深圳Ａ股交易日全部成交或撤销（已持有证券代码）-T+0卖'
logger.warning(title)
wt_reqs['side'] = Api.const.XTP_SIDE_TYPE['XTP_SIDE_SELL']
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ',' + str(rs['用例错误源']) +
',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True)
def test_YW_GGQQ_YWFXJHA_GU_123(self):
title = '买平（义务方平仓）：限价-验资（可用资金刚好）（下单金额<费用&&可用资金=（费用-下单金额））'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': '全成',
'errorID': 0,
'errorMSG': '',
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('11002397', '1', '*', '1', '0', 'P',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
logger.error('查询结果为False,错误原因: {0}'.format(
json.dumps(rs['测试错误原因'], encoding='UTF-8',
ensure_ascii=False)))
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type':
Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_OPTION'],
'order_client_id':
2,
'market':
Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker':
stkparm['证券代码'],
'side':
Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'position_effect':
Api.const.
XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_CLOSE'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_LIMIT'],
'price':
stkparm['涨停价'],
'quantity':
1
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
if rs['用例测试结果']:
logger.warning('执行结果为{0}'.format(str(rs['用例测试结果'])))
else:
logger.warning('执行结果为{0},{1},{2}'.format(
str(rs['用例测试结果']), str(rs['用例错误源']),
json.dumps(rs['用例错误原因'],
encoding='UTF-8',
ensure_ascii=False)))
self.assertEqual(rs['用例测试结果'], True) # 4
def test_YW_GGQQ_QLFSJHA_086(self):
title = '买开（权利方开仓）：市价剩余撤销-全成再撤单（OMS）'
#定义当前测试用例的期待值
#期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
#xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': '全成',
'errorID': 11000343,
'errorMSG': queryOrderErrorMsg(11000343),
'是否生成报单': '是',
'是否是撤废': '是',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、期望状态、Api
stkparm = QueryStkPriceQty('999999', '1', '*', '1', '0', '*',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
logger.error('查询结果为False,错误原因: {0}'.format(
json.dumps(rs['测试错误原因'], encoding='UTF-8',
ensure_ascii=False)))
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type':
Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_OPTION'],
'order_client_id':
2,
'market':
Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker':
stkparm['证券代码'],
'side':
Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'position_effect':
Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_OPEN'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_BEST_OR_CANCEL'],
'price':
stkparm['随机中间价'],
'quantity':
2
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
if rs['用例测试结果']:
logger.warning('执行结果为{0}'.format(str(rs['用例测试结果'])))
else:
logger.warning('执行结果为{0},{1},{2}'.format(
str(rs['用例测试结果']), str(rs['用例错误源']),
json.dumps(rs['用例错误原因'],
encoding='UTF-8',
ensure_ascii=False)))
self.assertEqual(rs['用例测试结果'], True) # 0
def test_YW_TSZLMM_SHXJ_099(self):
title = '交易日限价委托卖-先卖零头股再卖整数股'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
# 撤废:期望状态+是否是撤废=撤废类型。全成+是=oms全成后再撤单废单，未成交+是=交易所撤废，部撤+是=oms部撤后再撤单撤废，废单+是=废单后再撤废，已撤+是=oms已撤后再撤废
case_goal = {
'期望状态': '全成',
'errorID': 0,
'errorMSG': '',
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('604043', '1', '0', '2', '0', 'S',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
self.assertEqual(rs['用例测试结果'], True)
wt_reqs = {
'business_type':
Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':
2,
'market':
Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker':
stkparm['证券代码'],
'side':
Api.const.XTP_SIDE_TYPE['XTP_SIDE_SELL'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_LIMIT'],
'price':
stkparm['随机中间价'],
'quantity':
99,
'position_effect':
Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
# 卖出零头股
title = '上海Ａ股股票限价卖出先卖零头股再卖整数股-卖零头股'
logger.warning(title)
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ',' + str(rs['用例错误源']) +
',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True)
# 卖出整数股
title = '上海Ａ股股票限价卖出先卖零头股再卖整数股-卖整数股'
logger.warning(title)
wt_reqs['quantity'] = 10300
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ',' + str(rs['用例错误源']) +
',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True)
def test_YW_KCB_HASPRICELIMIT_GPMM_SHSJ_WDZX_135(self):
title = '交易日五档即成转限价-T+0卖→T+0买 卖全部300,再买300'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': '全成',
'errorID': 0,
'errorMSG': queryOrderErrorMsg(0),
'是否生成报单': '是',
'是否是撤废': '否',
# '是否是新股申购': '',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('688008', '1', '4', '2', '0', 'S', case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
print(stkparm['错误原因'])
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type': Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':2,
'market': Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker': stkparm['证券代码'],
'side': Api.const.XTP_SIDE_TYPE['XTP_SIDE_SELL'],
'price_type': Api.const.XTP_PRICE_TYPE['XTP_PRICE_BEST5_OR_LIMIT'],
'price': stkparm['涨停价'],
'quantity': 300,
'position_effect':Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('第一单执行结果为' + str(rs['用例测试结果']) + ','
+ str(rs['用例错误源']) + ',' + str(rs['用例错误原因']))
#self.assertEqual(rs['用例测试结果'], True) # 218
## 下第二单:
title = '下第二单:'
logger.warning(title)
wt_reqs["quantity"] = 300
wt_reqs["side"] = Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY']
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs_second = serviceTest(Api, case_goal, wt_reqs)
logger.warning('第二单执行结果为' + str(rs_second['用例测试结果']) + ','
+ str(rs_second['用例错误源']) + ',' + str(rs_second['用例错误原因']))
if rs['用例测试结果'] == True:
self.assertEqual(rs_second['用例测试结果'], True) #
else:
self.assertEqual(rs['用例测试结果'], True) #
def test_YW_KCB_HASNOPRICELIMIT_GPMM_SHSJ_WDZC_053(self):
title = '卖出最低特殊费用=0 xtp_default_fee_rate表改值'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': '全成',
'errorID': 0,
'errorMSG': queryOrderErrorMsg(0),
'是否生成报单': '是',
'是否是撤废': '否',
# '是否是新股申购': '',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('688030', '1', '4', '2', '0', 'S',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
print(stkparm['错误原因'])
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type':
Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':
2,
'market':
Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker':
stkparm['证券代码'],
'side':
Api.const.XTP_SIDE_TYPE['XTP_SIDE_SELL'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_BEST5_OR_CANCEL'],
'price':
200,
'quantity':
300,
'position_effect':
Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ',' +
str(rs['用例错误源']) + ',' + str(rs['用例错误原因']))
## 还原费率表
sql_transfer = SqlData_Transfer()
sql_transfer.transfer_xtp_default_fee_rate('YW_KCB_BAK_000')
oms_restart()
self.assertEqual(rs['用例测试结果'], True) # 204
def test_YW_TSZLMM_SHXJ_104(self):
title = '交易日限价委托-T+0买→T+0卖（未持有证券代码）'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
# 撤废:期望状态+是否是撤废=撤废类型。全成+是=oms全成后再撤单废单，未成交+是=交易所撤废，部撤+是=oms部撤后再撤单撤废，废单+是=废单后再撤废，已撤+是=oms已撤后再撤废
case_goal = {
'期望状态': '全成',
'errorID': 0,
'errorMSG': '',
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('604048', '1', '0', '2', '0', 'B',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
self.assertEqual(rs['用例测试结果'], True)
wt_reqs = {
'business_type':
Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':
2,
'market':
Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker':
stkparm['证券代码'],
'side':
Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_LIMIT'],
'price':
stkparm['随机中间价'],
'quantity':
1000,
'position_effect':
Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
# T+0买
title = '上海Ａ股股票限价卖出交易日限价委托（未持有证券代码）-T+0买'
logger.warning(title)
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ',' + str(rs['用例错误源']) +
',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True)
# T+0卖
title = '上海Ａ股股票限价卖出交易日限价委托（未持有证券代码）-T+0卖'
logger.warning(title)
wt_reqs['side'] = Api.const.XTP_SIDE_TYPE['XTP_SIDE_SELL']
case_goal['期望状态'] = '废单'
case_goal['errorID'] = 11010121
#update ErrMsg --wx 20180521
# case_goal['errorMSG'] = 'Failed to check security quantity.'
case_goal['errorMSG'] = queryOrderErrorMsg(11010121)
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ',' + str(rs['用例错误源']) +
',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True)
def test_YW_CYB_QXJY_011(self):
title = 'OMS初始化—机构户--Fundinfo表：资金账号无创业板权限'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
updateSecuRightHasXSz()
updateSecuRightHasXSh()
updateFundRightHasNoX()
updateSetInvTy1()
clear_data_and_restart_all()
Api.trade.Logout()
Api.trade.Login()
case_goal = {
'期望状态': '废单',
'errorID': 11000552,
'errorMSG': queryOrderErrorMsg(11000552),
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、买卖方向（Ｂ买Ｓ卖）、期望状态、Api
stkparm = QueryStkPriceQty('300023', '2', '2', '2', '0', 'B',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type':
Api.const.XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_CASH'],
'order_client_id':
2,
'market':
Api.const.XTP_MARKET_TYPE['XTP_MKT_SZ_A'],
'ticker':
stkparm['证券代码'],
'side':
Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_LIMIT'],
'price':
stkparm['涨停价'],
'quantity':
200,
'position_effect':
Api.const.XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_INIT']
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
logger.warning('执行结果为' + str(rs['用例测试结果']) + ',' +
str(rs['用例错误源']) + ',' + str(rs['用例错误原因']))
self.assertEqual(rs['用例测试结果'], True) # 420
updateSetInvTy0()
def test_sj_right_init(self):
title = '卖开（义务方开仓）：T日增加11002633和20002438空头持仓'
# 定义当前测试用例的期待值
# 期望状态：初始、未成交、部成、全成、部撤已报、部撤、已报待撤、已撤、废单、撤废、内部撤单
# xtp_ID和cancel_xtpID默认为0，不需要变动
case_goal = {
'期望状态': '全成',
'errorID': 0,
'errorMSG': '',
'是否生成报单': '是',
'是否是撤废': '否',
'xtp_ID': 0,
'cancel_xtpID': 0,
}
logger.warning(title)
# 定义委托参数信息------------------------------------------
# 参数：证券代码、市场、证券类型、证券状态、交易状态、期望状态、Api
for i in xrange(1):
for code, quantity in {'20002438': 10000}.items():
stkparm = QueryStkPriceQty(code, '1', '*', '1', '0', '*',
case_goal['期望状态'], Api)
# 如果下单参数获取失败，则用例失败
if stkparm['返回结果'] is False:
rs = {
'用例测试结果': stkparm['返回结果'],
'测试错误原因': '获取下单参数失败,' + stkparm['错误原因'],
}
logger.error('查询结果为False,错误原因: {0}'.format(
json.dumps(rs['测试错误原因'],
encoding='UTF-8',
ensure_ascii=False)))
self.assertEqual(rs['用例测试结果'], True)
else:
wt_reqs = {
'business_type':
Api.const.
XTP_BUSINESS_TYPE['XTP_BUSINESS_TYPE_OPTION'],
'order_client_id':
2,
'market':
Api.const.XTP_MARKET_TYPE['XTP_MKT_SH_A'],
'ticker':
stkparm['证券代码'],
'side':
Api.const.XTP_SIDE_TYPE['XTP_SIDE_BUY'],
'position_effect':
Api.const.
XTP_POSITION_EFFECT_TYPE['XTP_POSITION_EFFECT_OPEN'],
'price_type':
Api.const.XTP_PRICE_TYPE['XTP_PRICE_LIMIT'],
'price':
stkparm['随机中间价'],
'quantity':
quantity
}
ParmIni(Api, case_goal['期望状态'], wt_reqs['price_type'])
CaseParmInsertMysql(case_goal, wt_reqs)
rs = serviceTest(Api, case_goal, wt_reqs)
if rs['用例测试结果']:
logger.warning('执行结果为{0}'.format(str(rs['用例测试结果'])))
else:
logger.warning('执行结果为{0},{1},{2}'.format(
str(rs['用例测试结果']), str(rs['用例错误源']),
json.dumps(rs['用例错误原因'],
encoding='UTF-8',
ensure_ascii=False)))
self.assertEqual(rs['用例测试结果'], True) # 0
time.sleep(2)
