def setUp(self):
self.qwo = QualityWorkOrder()
self.tqo = TrackQualityOrder()
self.qualityWorkOrder_data = {
"smBusiUnitGid": "7e2c4ba1d1f64ad7b214a233c7ebb0fb",
"code": pm.create_code(),
"mdMaterialGid": params.MaterielSJGid,
"shouldCheckQty": 10
}
resp1 = self.qwo.qualityWorkOrder_create(self.qualityWorkOrder_data)
# print(resp1)
# 直接创建一条质检工单
self.trackQualityOrder_data = {
"code": pm.create_code(),
"qcDispatchedQty": 1,
"mdFactoryWorkStationGid": "",
"imeQcQualityWayGid": "",
"surveyor": "",
"checkBeginTime": "",
"checkEndTime": "",
"remarks": "",
"imeQcQacGid": resp1.pop("data"),
"imeQcQacCode": "",
"mdMaterialGid": "",
"mdProductInfoGid": "",
"qcHasDispatchedQty": "",
"qcHasInspectionQty": "",
"qcDispatchedPersonGid": ""
}
def setUp(self):
self.qwo = QualityWorkOrder()
self.tqo = TrackQualityOrder()
self.qr = QualityRecord()
self.qualityWorkOrder_data = {
"smBusiUnitGid": "7e2c4ba1d1f64ad7b214a233c7ebb0fb",
"code": pm.create_code(),
"mdMaterialGid": params.MaterielSJGid,
"shouldCheckQty": 10
}
resp1 = self.qwo.qualityWorkOrder_create(self.qualityWorkOrder_data)
# print(resp1)
# 直接创建一条质检工单
self.trackQualityOrder_data = {
"code": pm.create_code(),
"qcDispatchedQty": 5,
"mdFactoryWorkStationGid": "",
"imeQcQualityWayGid": "",
"surveyor": "",
"checkBeginTime": "",
"checkEndTime": "",
"remarks": "",
"imeQcQacGid": resp1.pop("data"),
"imeQcQacCode": "",
"mdMaterialGid": "",
"mdProductInfoGid": "",
"qcHasDispatchedQty": "",
"qcHasInspectionQty": "",
"qcDispatchedPersonGid": ""
}
resp2 = self.tqo.trackQualityOrder_add(self.trackQualityOrder_data)
print("resp2")
print(resp2)
# 对质检工单做派检
self.qualityRecord_data = {
"code": "",
"qcInspectionQty": 2,
"imeQcQacBillGid": resp2.pop("data")
}
resp3 = self.qr.qualityRecord_add(self.qualityRecord_data)
print("resp3")
print(resp3)
# 根据派检单生成报检单
self.reportRecord_data = {
"qualifiedQty": 1,
"unQualifiedQty": 1,
"imeQcQualityGradeGid": "",
"qcHandleWay": "返工返修",
"gid": resp3.pop("data")
}
def test_workorder_create_1(self):
"""工单参照生成接口测试：参照数量大于计划数量"""
code = "PO" + create_code()
print('订单编码：', code)
self.planOrder_mock_data['code'] = code
# 订单创建
self.po.planorder_create = Mock(side_effect=self.po.planorder_create)
resp = self.po.planorder_create(self.planOrder_mock_data)
planOrderGidList = []
planOrderGid = resp.pop('data')
planOrderGidList.append(planOrderGid)
# 订单下发修改状态
self.po.planorder_changeStatut = Mock(side_effect=self.po.planorder_changeStatut)
self.po.planorder_changeStatut(planOrderGidList)
# 工单参照订单生成
insertBy_mock_data = [
{
"gid": planOrderGid,
"refCreateQty": 11
}
]
self.wo.workorder_insertByPlanOrder = Mock(side_effect=self.wo.workorder_insertByPlanOrder)
resp = self.wo.workorder_insertByPlanOrder(insertBy_mock_data)
print('Response：', resp)
# 验证异常码为105000
self.assertEqual(105000, resp.pop('code'))
def test_workorder_senddown_1(self):
"""工单下发接口测试：下发生成派工单"""
# 工单创建
code = 'WO' + create_code()
self.workOrder_mock_data['code'] = code
self.wo.workorder_create = Mock(side_effect=self.wo.workorder_create)
resp = self.wo.workorder_create(self.workOrder_mock_data)
print('Response：', resp)
# self.assertEqual(self.po.planorder_create(mock_data), mock_resp)
workOrderGidList = []
workOrderGid = resp.pop('data')
workOrderGidList.append(workOrderGid)
# 工单下发
self.wo.workorder_release = Mock(side_effect=self.wo.workorder_release)
self.wo.workorder_release(workOrderGidList)
# 派工单查询
self.track_query_data.get('query').get(
'query')[0]['value'] = workOrderGid
self.to.trackorder_findByWorkOrderGid = Mock(
side_effect=self.to.trackorder_findByWorkOrderGid)
resp = self.to.trackorder_findByWorkOrderGid(self.track_query_data)
trackList = resp.pop('data')
print('trackList：', trackList)
# 验证派工单生成数量为2
self.assertEqual(2, len(trackList))
def test_planorder_senddown_2(self):
"""订单下发接口测试：下发生产工单回写生产订单已生成数量验证"""
planOrderGidList = []
# 订单创建
code = "PO" + create_code()
print('订单编码：', code)
self.planOrder_mock_data['code'] = code
self.po.planorder_create = Mock(side_effect=self.po.planorder_create)
resp = self.po.planorder_create(self.planOrder_mock_data)
planOrderGid = resp.pop('data')
planOrderGidList.append(planOrderGid)
# 订单下发
self.po.planorder_release = Mock(side_effect=self.po.planorder_release)
resp = self.po.planorder_release(planOrderGidList)
print('Response：', resp)
planOrderGid = resp.get('data')[0]
# 订单查询
self.po.planorder_findById = Mock(side_effect=self.po.planorder_findById)
resp = self.po.planorder_findById(planOrderGid)
print('Response：', resp)
# 验证已下发数量为10
self.assertEqual(10, resp.pop('data').pop('publishedQty'))
def setUp(self):
self.qct = QualityCollectTemplate()
self.QualityCollectTemplate_data = {
"code": pm.create_code(),
"name": "模板Aug",
"materialGid": params.MaterielSJGid,
"bmOperationGid": params.bmOperationInfoCPUGid,
"bmOperationCode": "001",
"bmOperationName": "CPU工序"
}
def setUp(self):
self.wo = WorkOrder()
self.qwo = QualityWorkOrder()
self.workOrder_mock_data = {
"code": pm.create_code(),
"resourceOrderGid": "",
"materialGid": params.MaterielSJGid,
"orderType": "62DC90DAFA845CB2E055000000000001",
"workCenterGid": params.bmFactoryWorkCenterGid,
"factoryLineGid": params.bmFactoryLineCF,
"routeLineGid": "",
"planQty": 10,
"planBeginTime": "2018-05-01",
"planEndTime": "2018-05-31",
"actualBeginTime": "",
"actualEndTime": "",
"finishQty": "",
"measureBeginTime": "",
"measureEndTime": "",
"orderSeq": "",
"parentWorkOrderGid": "",
"freezeStatus": "",
"orderStatus": "",
"bomStatus": "",
"createStatus": "",
"roundNum": "",
"processStatus": "",
"createKmFlag": "",
"createQacFlag": "",
"repairCardGid": "",
"measurementUnitGid": params.bmMeasurementUnitGid,
"materialVersion": "1",
"busiActivityType": "",
"qualifiedQty": "",
"unqualifiedQty": "",
"wasteQty": "",
"batchNumber": "",
"productGid": "",
"workOrderCategory": "",
"bomVersion": "",
"routeLineVersion": "",
"canOperation": "",
"surplusOrderFlag": "",
"publishedQty": "",
"factoryLineType": "",
"generatedCode": ""
}
self.workOrder_Rule_data = {
"gid": "712E1C21843F5B4FE055000000000001",
"name": "是否下发",
"code": "IS_PUBLISH",
"description": "是否下发",
"activeRule": "false"
}
def setUp(self):
self.qct = QualityCollectTemplate()
self.QualityCollectTemplate_data = {
"code": pm.create_code(),
"name": "模板Aug",
"materialGid": params.MaterielSJGid,
"bmOperationGid": params.bmOperationInfoCPUGid,
"bmOperationCode": "001",
"bmOperationName": "CPU工序"
}
self.qualityIndexType_data = [{
"code": pm.create_code(),
"name": "分类Aug",
"childrenList": {
"code": pm.create_code(),
"name": "分类Aug-1"
}
}]
def test_qualityCollectionList_queryBy_QWO(self):
"""根据质检工单查询检测指标"""
# 创建质检工单
QWO_code = 'QWO' + pm.create_code()
self.qualityWorkOrder_data_create['code'] = QWO_code
resp_QWO_create = self.qwo.qualityWorkOrder_create(self.qualityWorkOrder_data_create)
QWOGid = resp_QWO_create.get('data')
resp_qcl_query = self.qc.qualityCollectList_query(QWOGid, 20010)
self.assertEqual(True, resp_qcl_query.pop("success"))
def test_inspecttask_add_1(self):
"""
点检任务创建
:return:
"""
code = create_code()
self.it_add_data['code'] = code
self.it.inspecttask_add = Mock(side_effect=self.it.inspecttask_add)
resp_it_add = self.it.inspecttask_add(self.it_add_data)
self.assertIn('data', resp_it_add.keys())
def test_planorder_create_1(self):
"""订单创建接口测试：输入正确的必填项生成订单"""
code = "PO" + create_code()
print('订单编码：', code)
self.planOrder_mock_data['code'] = code
self.po.planorder_create = Mock(side_effect=self.po.planorder_create)
resp = self.po.planorder_create(self.planOrder_mock_data)
print('Response：', resp)
# 验证订单GID存在
self.assertIn('data', resp.keys())
def test_qualityWorkOrderRef(self):
resp1 = self.qct.saveQualityCollectTemplate(
self.QualityCollectTemplate_data)
"""创建模板"""
self.qct.saveIndexType(self.qualityIndexType_data, resp1["data"])
"""指标分类创建"""
resp2 = self.qct.queryIndexTypeTree(resp1["data"])
"""根据指标分类模糊查询末级指标分类GID"""
self.QualityIndexValue_data = [{
"code":
pm.create_code(),
"name":
"指标Aug",
"descritption":
"TestDesc",
"value":
"TestValue",
"indexTypeGid":
resp2["data"][0]["childrenList"][0]["gid"],
"optionsType":
"characterType",
"indexOptionsList": [{
"code": pm.create_code(),
"name": "选项01"
}, {
"code": pm.create_code(),
"name": "选项02"
}]
}]
resp3 = self.qct.saveIndexValue(self.QualityIndexValue_data)
"""保存指标值，同时保存选项"""
self.assertEqual(True, resp3["success"])
self.assertIsNotNone(resp3["data"])
def test_inspecttask_addAndTrack_1(self):
"""
点检任务创建并派工
:return:
"""
code = create_code()
self.it_add_data['code'] = code
self.it.inspecttask_addAndTrack = Mock(
side_effect=self.it.inspecttask_addAndTrack)
resp_it_adda = self.it.inspecttask_addAndTrack(self.it_add_data)
self.assertIn('data', resp_it_adda.keys())
def test_inspecttask__1(self):
"""
点检任务更新
:return:
"""
code = create_code()
self.it_add_data['code'] = code
self.it.inspecttask_add = Mock(side_effect=self.it.inspecttask_add)
resp_it_add = self.it.inspecttask_add(self.it_add_data)
self.it_add_data['inspectTime'] = "2018-07-01 00:00:00"
self.it.inspecttask_modify = Mock(
side_effect=self.it.inspecttask_modify)
resp_it_modify = self.it.inspecttask_modify(self.it_add_data)
self.assertIn('success', resp_it_modify.keys())
def test_cl_createBy_qwo(self):
"""根据质检工单创建采集清单"""
# 直接创建一条质检工单
qwoCode = 'QWO' + pm.create_code()
self.qualityWorkOrder_data['code'] = qwoCode
resp_qwo_create = self.qwo.qualityWorkOrder_create(self.qualityWorkOrder_data)
qwoGid = resp_qwo_create.get('data')
self.qualityCollectList_data[0]['qcRefGid'] = qwoGid
self.qualityCollectList_data[0]['qcRefType'] = "20010"
resp_qcl_addBatch = self.qcl.qualityCollectList_addBatch(self.qualityCollectList_data)
self.assertLess(0, len(resp_qcl_addBatch.get('data')))
def test_inspecttask_findById_1(self):
"""
点检任务详情查询
:return:
"""
code = create_code()
self.it_add_data['code'] = code
self.it.inspecttask_add = Mock(side_effect=self.it.inspecttask_add)
resp_it_add = self.it.inspecttask_add(self.it_add_data)
it_gid = resp_it_add.get('data')
self.it.inspecttask_findById = Mock(
side_effect=self.it.inspecttask_findById)
resp_it_find = self.it.inspecttask_findById(it_gid)
self.assertIn('code', resp_it_find.get('data').keys())
def test_qualityCollectionList_queryBy_TQO(self):
"""根据派检单查询检测指标"""
# 创建质检工单
QWO_code = 'QWO' + pm.create_code()
self.qualityWorkOrder_data_create['code'] = QWO_code
resp_QWO_create = self.qwo.qualityWorkOrder_create(self.qualityWorkOrder_data_create)
QWOGid = resp_QWO_create.get('data')
# 生成派检单
self.tqo_data_create['imeQcQacGid'] = QWOGid
self.tqo_data_create['imeQcQacCode'] = QWO_code
resp_TQO_create = self.tqo.trackQualityOrder_add(self.tqo_data_create)
tqoGid = resp_TQO_create.get('data')
resp_qcl_query = self.qc.qualityCollectList_query(tqoGid, 20011)
self.assertEqual(True, resp_qcl_query.pop("success"))
def workorder_changestatus():
# 工单创建
wo = WorkOrder()
code = 'WO' + create_code()
workOrder_mock_data['code'] = code
wo.workorder_create = Mock(side_effect=wo.workorder_create)
resp = wo.workorder_create(workOrder_mock_data)
print('Response：', resp)
# self.assertEqual(self.po.planorder_create(mock_data), mock_resp)
workOrderGidList = []
workOrderGid = resp.pop('data')
workOrderGidList.append(workOrderGid)
# 工单下发
wo.workorder_changeStatut = Mock(side_effect=wo.workorder_changeStatut)
wo.workorder_changeStatut(workOrderGidList)
return workOrderGidList
def test_inspecttask_report_1(self):
"""
点检任务报工
:return:
"""
code = create_code()
self.it_add_data['code'] = code
self.it.inspecttask_addAndTrack = Mock(
side_effect=self.it.inspecttask_addAndTrack)
resp_it_adda = self.it.inspecttask_addAndTrack(self.it_add_data)
it_gid = resp_it_adda.get('data')
self.it_report_data['gid'] = it_gid
self.it.inspecttask_report = Mock(
side_effect=self.it.inspecttask_report)
resp_it_report = self.it.inspecttask_report(self.it_report_data)
self.assertIn('success', resp_it_report.keys())
def setUp(self):
self.qr = QualityRecord()
self.qwo = QualityWorkOrder()
self.qualityWorkOrder_data = {
"smBusiUnitGid": "7e2c4ba1d1f64ad7b214a233c7ebb0fb",
"code": pm.create_code(),
"mdMaterialGid": params.MaterielSJGid,
"shouldCheckQty": 10
}
resp1 = self.qwo.qualityWorkOrder_create(self.qualityWorkOrder_data)
# print(resp1)
# 直接创建一条质检工单
self.qualityRecord_data = {
"code": "",
"qcInspectionQty": 5,
"imeQcQacGid": resp1.pop("data")
}
def test_mrwh_autoWarehouse_1(self):
"""
物料需求按条件自动分配仓库
:return:
"""
code = create_code()
self.mr_create_data['code'] = code
self.mr.materialmrequirement_add = Mock(
side_effect=self.mr.materialmrequirement_add)
resp_mr_add = self.mr.materialmrequirement_add(self.mr_create_data)
mr_gid = resp_mr_add.get('data')
self.mr_query_data['query']['query'][0]['value'] = code
self.mr.materialmrequirement_autoWarehouse = Mock(
side_effect=self.mr.materialmrequirement_autoWarehouse)
resp_mr_auwh = self.mr.materialmrequirement_autoWarehouse(
self.mr_query_data)
# 验证返回中的物料需求GID存在且为1
self.assertEqual(1, len(resp_mr_auwh.get('data')))
def test_mrwh_manuallyWarehouse_1(self):
"""
物料需求手工分配仓库
:return:
"""
code = create_code()
self.mr_create_data['code'] = code
self.mr.materialmrequirement_add = Mock(
side_effect=self.mr.materialmrequirement_add)
resp_mr_add = self.mr.materialmrequirement_add(self.mr_create_data)
mr_gid_list = []
mr_gid = resp_mr_add.get('data')
mr_gid_list.append(mr_gid)
self.mr_mauwh_data['gids'] = mr_gid_list
self.mr.materialmrequirement_manuallyWarehouse = Mock(
side_effect=self.mr.materialmrequirement_manuallyWarehouse)
resp_mr_mauwh = self.mr.materialmrequirement_manuallyWarehouse(
self.mr_mauwh_data)
self.assertEqual(1, len(resp_mr_mauwh.get('data')))
def test_planorder_senddown_1(self):
"""订单下发接口测试：下发生产工单数量验证"""
planOrderGidList = []
# 订单创建
code = "PO" + create_code()
print('订单编码：', code)
self.planOrder_mock_data['code'] = code
self.po.planorder_create = Mock(side_effect=self.po.planorder_create)
resp = self.po.planorder_create(self.planOrder_mock_data)
planOrderGid = resp.pop('data')
planOrderGidList.append(planOrderGid)
# 订单下发
self.po.planorder_release = Mock(side_effect=self.po.planorder_release)
resp = self.po.planorder_release(planOrderGidList)
print('Response：', resp)
# 验证生成工单数量为1
self.assertEqual(1, len(resp.pop('data')))
def test_reportorder_report_2(self):
"""报工接口测试：全部不良品报工"""
# 工单创建
code = 'WO' + create_code()
self.workOrder_mock_data['code'] = code
self.wo.workorder_create = Mock(side_effect=self.wo.workorder_create)
resp = self.wo.workorder_create(self.workOrder_mock_data)
print('Response：', resp)
# self.assertEqual(self.po.planorder_create(mock_data), mock_resp)
workOrderGidList = []
workOrderGid = resp.pop('data')
workOrderGidList.append(workOrderGid)
# 工单下发
self.wo.workorder_changeStatut = Mock(
side_effect=self.wo.workorder_changeStatut)
self.wo.workorder_changeStatut(workOrderGidList)
# 派工单参照生成
self.track_mock_data[0]['orderId'] = workOrderGid
self.track_mock_data[0]['refenceQty'] = 10
self.to.trackorder_createByWorkOrder = Mock(
side_effect=self.to.trackorder_createByWorkOrder)
resp = self.to.trackorder_createByWorkOrder(self.track_mock_data)
# 派工单查询
self.track_query_data.get('query').get('query')[0]['value'] = code
self.to.trackorder_findByWorkOrderGid = Mock(
side_effect=self.to.trackorder_findByWorkOrderGid)
resp = self.to.trackorder_findByWorkOrderGid(self.track_query_data)
trackList = resp.pop('data')
track = trackList[0]
# 派工及报工参照拼接
imeTrackOrderOperationList = []
imeReportOrderOperationsList = []
for trackOrderOperation in track.get('imeTrackOrderOperationList'):
tooGid = trackOrderOperation.get('gid')
toot = {'gid': tooGid, 'curTrackQty': 10}
imeTrackOrderOperationList.append(toot)
toor = {
'operationGid': tooGid,
'curQualifiedQty': 0,
'curRepairQty': 10
}
imeReportOrderOperationsList.append(toor)
trackGid = track.get('gid')
self.track_assign_data['gid'] = trackGid
self.track_assign_data['workUnitGid'] = params.bmFactoryWorkUnitCF
self.track_assign_data[
'imeTrackOrderOperationList'] = imeTrackOrderOperationList
self.report_mock_data['reportOrderId'] = trackGid
self.report_mock_data[
'imeReportOrderOperations'] = imeReportOrderOperationsList
self.report_mock_data['resourceOrderType'] = 10030
self.to.trackorder_assign = Mock(side_effect=self.to.trackorder_assign)
resp = self.to.trackorder_assign(self.track_assign_data)
self.ro.reportorder_report = Mock(
side_effect=self.ro.reportorder_report)
resp = self.ro.reportorder_report(self.report_mock_data)
# 验证报工记录为3条
self.assertEqual(3, len(resp.pop('data')))
def smoke_equipment(self):
"""设备流程冒烟"""
print(get_time(), ' START：设备模块冒烟测试')
print(get_time(), ' START：设备点检冒烟测试')
# 创建设备
try:
self.eqm_add_data['name'] = 'IT_Equipment_' + create_code()
self.eqm_add_data['code'] = 'IT_Equipment_' + create_code()
resp_eqm_add = self.eqm.equipment_create(self.eqm_add_data)
if 'code' in resp_eqm_add.keys():
self.msg = resp_eqm_add.get('message')
self.assertNotIn('code',
resp_eqm_add.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('data',
resp_eqm_add.keys(),
msg=get_time() + ' ERROR：设备创建失败')
self.eqm_gid = resp_eqm_add.get('data')
print(get_time(), ' INFO：设备GID：', self.eqm_gid)
except Exception as e:
print(get_time(), ' ERROR：', e)
# 创建点检策略
try:
self.isy_add_data[0]['bmEquipmentGid'] = self.eqm_gid
resp_isy_add = self.isy.inspectstrategiy_addBatch(
self.isy_add_data)
if 'code' in resp_isy_add.keys():
self.msg = resp_isy_add.get('message')
self.assertNotIn('code',
resp_isy_add.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('data',
resp_isy_add.keys(),
msg=get_time() + ' ERROR：设备点检策略创建失败')
self.isy_gid = resp_isy_add.get('data')
print(get_time(), ' INFO：设备点检策略GID：', self.isy_gid)
except Exception as e:
print(get_time(), ' ERROR：', e)
# 点检任务参照策略创建
try:
self.it_addf_data['bmEquipmentGid'] = self.eqm_gid
resp_it_addaf = self.it.inspecttask_addFromInspectStrategy(
self.it_addf_data)
if 'code' in resp_it_addaf.keys():
self.msg = resp_it_addaf.get('message')
self.assertNotIn('code',
resp_it_addaf.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('data',
resp_it_addaf.keys(),
msg=get_time() + ' ERROR：设备点检任务创建失败')
self.it_gid_list = resp_it_addaf.get('data')
print(get_time(), ' INFO：设备点检任务GIDList：', self.it_gid_list)
except Exception as e:
print(get_time(), ' ERROR：', e)
# 点检任务派工
try:
self.it_track_data['gids'] = self.it_gid_list
resp_it_track = self.it.inspecttask_track(self.it_track_data)
if 'code' in resp_it_track.keys():
self.msg = resp_it_track.get('message')
self.assertNotIn('code',
resp_it_track.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('success',
resp_it_track.keys(),
msg=get_time() + ' ERROR：点检任务派工失败')
print(get_time(), ' INFO：点检任务派工成功')
except Exception as e:
print(get_time(), ' ERROR：', e)
# 点检任务报工
try:
self.it_report_data['gid'] = self.it_gid_list[0]
resp_it_report = self.it.inspecttask_report(self.it_report_data)
if 'code' in resp_it_report.keys():
self.msg = resp_it_report.get('message')
self.assertNotIn('code',
resp_it_report.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('success',
resp_it_report.keys(),
msg=get_time() + ' ERROR：点检任务报工失败')
print(get_time(), ' INFO：点检任务报工成功')
print(get_time(), ' END：设备点检冒烟成功')
self.test_sb_status = True
except Exception as e:
print(get_time(), ' ERROR：', e)
def smoke_production(self):
"""生产流程冒烟"""
print(get_time(), ' START：生产模块冒烟测试')
# 创建订单
po_code = 'PO' + create_code()
print(get_time(), ' INFO：【生产订单】预创建，编码：', po_code)
self.planOrder_create_data['code'] = po_code
try:
resp_planorder_create = self.po.planorder_create(
self.planOrder_create_data)
if 'code' in resp_planorder_create.keys():
self.msg = resp_planorder_create.get('message')
self.assertNotIn('code',
resp_planorder_create.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.po_gid = resp_planorder_create.get('data') # 订单GID
self.assertNotEqual(self.po_gid, None, msg='ERROR：生产订单创建失败')
print(get_time(), ' INFO：【生产订单】创建成功，订单GID：', self.po_gid)
except Exception as e:
print(get_time(), ' ERROR：', e)
# 订单下发
try:
resp_planorder_release = self.po.planorder_release([self.po_gid])
if 'code' in resp_planorder_release.keys():
self.msg = resp_planorder_release.get('message')
self.assertNotIn('code',
resp_planorder_release.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.wo_gid_list = resp_planorder_release.get('data') # 工单GID
print(get_time(), ' INFO：【生产订单】下发成功，生产工单GIDList：',
self.wo_gid_list)
except Exception as e:
print(get_time(), ' ERROR：', e)
# 查询工单信息获取工单编码
try:
self.wo_query_data['query']['query'][1]['value'] = po_code
resp_wo_query = self.wo.workorder_queryBy_data(self.wo_query_data)
if 'code' in resp_wo_query.keys():
self.msg = resp_wo_query.get('message')
self.assertNotIn('code',
resp_wo_query.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('code',
resp_wo_query.get('data')[0].keys(),
msg=get_time() + ' ERROR：未查询到生产工单信息')
self.wo_code = resp_wo_query.get('data')[0].get('code')
print(get_time(), ' INFO：【生产工单】编码：', self.wo_code)
except Exception as e:
print(get_time(), ' ERROR：', e)
# 工单下发方式
if self.way_workorder_sendown == 0:
# 工单下发修改状态
try:
resp_wo_changestatus = self.wo.workorder_changeStatut(
self.wo_gid_list)
if 'code' in resp_wo_changestatus.keys():
self.msg = resp_wo_changestatus.get('message')
self.assertNotIn('code',
resp_wo_changestatus.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('success',
resp_wo_changestatus.keys(),
msg=get_time() + ' ERROR：【生产工单】下发修改状态失败')
print(get_time(), ' INFO：【生产工单】下发修改状态成功')
except Exception as e:
print(get_time(), ' ERROR：', e)
# 参照工单生成派工单
try:
self.to_createby_data[0]['orderId'] = self.wo_gid_list[0]
resp_to_createby = self.to.trackorder_createByWorkOrder(
self.to_createby_data)
if 'code' in resp_to_createby.keys():
self.msg = resp_to_createby.get('message')
self.assertNotIn('code',
resp_to_createby.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('success',
resp_to_createby.keys(),
msg=get_time() + ' ERROR：【生产派工单】参照失败')
print(get_time(), ' INFO：【生产派工单】参照成功')
except Exception as e:
print(get_time(), ' ERROR：', e)
elif self.way_workorder_sendown == 1:
# 工单下发生成派工单
try:
resp_wo_release = self.wo.workorder_release(self.wo_gid_list)
if 'code' in resp_wo_release.keys():
self.msg = resp_wo_release.get('message')
self.assertNotIn('code',
resp_wo_release.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('success',
resp_wo_release.keys(),
msg=get_time() + ' FAIL：【生产工单】下发失败')
print(get_time(), ' INFO：【生产工单】下发成功')
except Exception as e:
print(get_time(), ' ERROR：', e)
# 查询派工单
self.to_query_data['query']['query'][1]['value'] = self.wo_code
try:
resp_to_query = self.to.trackorder_queryByData(self.to_query_data)
if 'code' in resp_to_query.keys():
self.msg = resp_to_query.get('message')
self.assertNotIn('code',
resp_to_query.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertLess(0,
len(resp_to_query.get('data')),
msg=get_time() + ' ERROR：未查询到生产派工单信息')
print(get_time(), ' INFO：【生产派工单】编码：',
resp_to_query.get('data')[0].get('code'))
self.to_gid = resp_to_query.get('data')[0].get('gid')
self.to_oper_list = resp_to_query.get('data')[0].get(
'imeTrackOrderOperationList')
except Exception as e:
print(get_time(), ' ERROR：', e)
# 生产派工
if self.way_workorder_sendown == 0:
try:
i = 0
self.to_assign_data['gid'] = self.to_gid
for to_oper in self.to_oper_list:
to_oper_gid = to_oper.get('gid')
self.to_assign_data['imeTrackOrderOperationList'][i][
'gid'] = to_oper_gid
i += 1
resp_to_assign = self.to.trackorder_assign(self.to_assign_data)
if 'code' in resp_to_assign.keys():
self.msg = resp_to_assign.get('message')
self.assertNotIn('code',
resp_to_assign.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('data',
resp_to_assign.keys(),
msg=get_time() + ' ERROR：生产派工失败')
print(get_time(), ' INFO：【生产派工】成功')
except Exception as e:
print(get_time(), ' ERROR：', e)
# 生产报工
self.ro_report_data['reportOrderId'] = self.to_gid
i = 0
for imeTrackOrderOperation in self.to_oper_list:
to_oper_gid = imeTrackOrderOperation.get('gid')
self.ro_report_data['imeReportOrderOperations'][i][
'operationGid'] = to_oper_gid
i += 1
try:
resp_ro_report = self.ro.reportorder_report(self.ro_report_data)
if 'code' in resp_ro_report.keys():
self.msg = resp_ro_report.get('message')
self.assertNotIn('code',
resp_ro_report.keys(),
msg=get_time() + ' ERROR：' + self.msg)
self.assertIn('data',
resp_ro_report.keys(),
msg=get_time() + ' ERROR：生产报工失败')
self.assertEqual(2,
len(resp_ro_report.get('data')),
msg=get_time() + ' ERROR：生产报工失败')
print(get_time(), ' INFO：【生产派工单】报工成功')
print(get_time(), ' END：生产模块冒烟成功')
self.test_sc_status = True
except Exception as e:
print(get_time(), ' ERROR：', e)
