3 ##############################################################################
4 # Copyright (c) 2018 HUAWEI TECHNOLOGIES CO.,LTD and others.
6 # All rights reserved. This program and the accompanying materials
7 # are made available under the terms of the Apache License, Version 2.0
8 # which accompanies this distribution, and is available at
9 # http://www.apache.org/licenses/LICENSE-2.0
10 ##############################################################################
17 from src.step.step_manager import TestStepManager
18 from src.conductor_processor.workflow import WorkflowFile
19 from conductorclient.run_new_workflow import WorkflowMgr
21 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
22 CONDUCTOR_SERVER_ADDR = "http://conductor_conductor-server_1:8080"
23 STORE_TASK_PATH = "/tmp/generate_task.json"
24 STORE_WF_PATH = "/tmp/generate_workflow.json"
28 @click.option("--filepath", help="file path of test case")
29 def cmdParse(filepath):
34 filePrefix, fileName = os.path.split(filepath)
35 print '------------ start to parse the test case:' + \
36 '%s ----------------' % fileName
37 with open(filepath) as f:
38 yaml_file = yaml.load(f)
39 parseTestcase(yaml_file['schema'], fileName)
41 workflowId = runWorkFlow()
42 print '------------------- parse executes end -------------------------'
47 def parseTestcase(schema, tcName='testcase0.yaml'):
49 tcName.decode('ascii')
52 tcName = 'testcase0.yaml'
54 return parseLog(False, reason='schema not found.')
55 steps = schema['steps']
57 return parseLog(False, reason='steps is invalid.')
58 flows = schema['flows']
60 return parseLog(False, reasion='flows is invalid.')
61 # steps is a list, step is dict. no json here.
62 # steps = sorted(steps, sortById)
66 contextDir = os.path.join(BASE_DIR, "env", "context", "context.yaml")
67 with open(contextDir, "r") as f:
68 contextDict = yaml.load(f)
70 testStepMgr = TestStepManager(contextDict)
74 if 'args' not in step:
76 # type and action can be extended, default couple is 'test' & 'start'.
77 if 'type' not in step:
79 step['action'] = 'start'
81 stepObj = testStepMgr.getStepObj(
82 step['type'], step['id'], step['name'], step['service'],
83 step['action'], step['args'])
84 stepObjArr.append(stepObj)
86 # generate workflow by 'flow' and 'step'
87 tcName = os.path.splitext(tcName)[0]
88 wfFileObj = WorkflowFile(tcName)
89 workflowDict, taskMetaList = wfFileObj.generateMetaData(flows, stepObjArr)
91 with open(STORE_TASK_PATH, 'w') as f:
92 f.write(json.dumps({'task_group': taskMetaList}, indent=True))
93 with open(STORE_WF_PATH, 'w') as f:
94 f.write(json.dumps(workflowDict, indent=True))
97 def parseWebTestcase(webTestcase):
98 print 'parseWebTestcase----------------------------'
100 stepList = webTestcase['stepList']
101 mainOrdersList = webTestcase['mainOrdersList']
102 subflowList = webTestcase['subflowList']
104 parseData = collections.OrderedDict()
105 parseData['schema'] = collections.OrderedDict()
106 parseData['schema']['steps'] = []
107 parseData['schema']['flows'] = []
109 parseStepList = parseData['schema']['steps']
110 parseFlowList = parseData['schema']['flows']
113 for index in range(len(stepList)):
114 stepItem = stepList[index]
115 parseStep = collections.OrderedDict()
117 parseStep['id'] = index + 1
118 parseStep['name'] = stepItem['name']
119 parseStep['service'] = collections.OrderedDict()
120 parseStep['service']['name'] = stepItem['service']
121 parseStep['service']['interface'] = stepItem['action']
122 parseStep['action'] = 'start'
123 parseStep['args'] = {}
124 for paramItem in stepItem['params']:
125 parseStep['args'][paramItem['key']] = transParamString(
128 parseStepList.append(parseStep)
129 stepIndexDict[parseStep['name']] = parseStep['id']
133 typeDict = {1: 'normal', 2: 'switch', 3: 'parallel'}
134 mainFlow = collections.OrderedDict()
135 mainFlow['name'] = 'main'
136 mainFlow['orders'] = []
137 mainFlow['orders'] = parseOrderList(
138 mainOrdersList, stepIndexDict, typeDict)
139 parseFlowList.append(mainFlow)
142 for subflowItem in subflowList:
143 replaceSubflow = collections.OrderedDict()
144 replaceSubflow['name'] = subflowItem['name']
145 replaceSubflow['orders'] = parseOrderList(
146 subflowItem['orderList'], stepIndexDict, typeDict)
147 parseFlowList.append(replaceSubflow)
149 print 'END parseWebTestcase----------------------------'
153 # parse orderlist from web edition to server edition
154 def parseOrderList(orderList, stepIndexDict, typeDict):
156 for orderItem in orderList:
157 replaceOrder = collections.OrderedDict()
158 orderType = typeDict[orderItem['type']]
159 replaceOrder['type'] = orderType
160 if orderType == 'normal':
161 stepId = stepIndexDict[orderItem['step']]
162 replaceOrder['step'] = stepId
163 elif orderType == 'switch':
164 replaceOrder['value'] = orderItem['value']
165 replaceOrder['cases'] = collections.OrderedDict()
166 for caseItem in orderItem['cases']:
167 caseValue = caseItem['value']
168 caseOrderType = caseItem['orderType']
169 caseOrderValue = caseItem['orderValue']
170 if caseOrderType == "step":
171 orderInCase = collections.OrderedDict()
172 orderInCase['type'] = 'normal'
173 orderInCase['step'] = stepIndexDict[caseOrderValue]
174 replaceOrder['cases'][caseValue] = [orderInCase]
176 replaceOrder['cases'][caseValue] = caseOrderValue
178 replaceOrder['parallel'] = collections.OrderedDict()
180 for branchItem in orderItem['branches']:
181 pKey = 'p' + str(pIndex)
182 branchOrderType = branchItem['orderType']
183 branchOrderValue = branchItem['orderValue']
184 if branchOrderType == "step":
185 replaceBranchItem = collections.OrderedDict()
186 replaceBranchItem['type'] = 'normal'
187 replaceBranchItem['step'] = stepIndexDict[branchOrderValue]
188 replaceOrder['parallel'][pKey] = [replaceBranchItem]
190 replaceOrder['parallel'][pKey] = branchOrderValue
192 replaceList.append(replaceOrder)
196 def transParamString(val):
209 def getWebTestcase(originTcDict):
210 print "getWebTestcase----------------------------------"
213 "mainOrdersList": [],
216 stepList = webTcDict['stepList']
217 subflowList = webTcDict['subflowList']
218 if originTcDict is None:
220 originContent = originTcDict['schema']
221 originSteps = originContent['steps']
223 # transform steps to stepList
224 for stepItem in originSteps:
226 replaceStep['name'] = stepItem['name']
227 replaceStep['service'] = stepItem['service']['name']
228 replaceStep['action'] = stepItem['service']['interface']
229 replaceStep['params'] = []
230 if 'args' in stepItem:
231 for (key, value) in stepItem['args'].items():
233 replaceParam['key'] = key
234 replaceParam['value'] = value
235 replaceStep['params'].append(replaceParam)
236 stepList.append(replaceStep)
237 stepIndexDict[stepItem['id']] = stepItem['name']
239 # transform main flow
240 originFlows = originContent['flows']
242 for flowIndex in range(len(originFlows)):
243 flowItem = originFlows[flowIndex]
244 if flowItem['name'] == 'main':
245 originMainflow = flowItem
246 originFlows.pop(flowIndex)
248 typeDict = {'normal': 1, 'switch': 2, 'parallel': 3}
249 webTcDict['mainOrdersList'] = getOrderList(
250 originMainflow['orders'], stepIndexDict, typeDict)
253 for originSubflow in originFlows:
255 replaceSubflow['name'] = originSubflow['name']
256 replaceSubflow['orderList'] = getOrderList(
257 originSubflow['orders'], stepIndexDict, typeDict)
258 subflowList.append(replaceSubflow)
260 # return web edition of testcase
261 print "END getWebTestcase----------------------------------"
265 def getOrderList(originOrderList, stepIndexDict, typeDict):
266 replaceOrderList = []
267 for orderItem in originOrderList:
268 replaceOrderItem = {}
269 orderType = orderItem['type']
270 replaceOrderItem['type'] = typeDict[orderType]
271 if orderType == 'normal':
272 stepName = stepIndexDict[orderItem['step']]
273 replaceOrderItem['step'] = stepName
274 elif orderType == 'switch':
275 replaceOrderItem['value'] = orderItem['value']
276 replaceOrderItem['cases'] = []
277 for (caseValue, ordersInCase) in orderItem['cases'].items():
279 replaceCase['value'] = caseValue
280 if type(ordersInCase) == list:
281 replaceCase['orderType'] = 'step'
282 caseStepName = stepIndexDict[ordersInCase[0]['step']]
283 replaceCase['orderValue'] = caseStepName
285 replaceCase['orderType'] = 'flow'
286 replaceCase['orderValue'] = ordersInCase
287 replaceOrderItem['cases'].append(replaceCase)
289 replaceOrderItem['branches'] = []
290 for paraIndex in orderItem['parallel']:
291 paraItem = orderItem['parallel'][paraIndex]
293 if type(paraItem) == list:
294 replaceBranch['orderType'] = 'step'
295 branchStepName = stepIndexDict[paraItem[0]['step']]
296 replaceBranch['orderValue'] = branchStepName
298 replaceBranch['orderType'] = 'flow'
299 replaceBranch['orderValue'] = paraItem
300 replaceOrderItem['branches'].append(replaceBranch)
301 replaceOrderList.append(replaceOrderItem)
303 return replaceOrderList
307 wfMgr = WorkflowMgr(CONDUCTOR_SERVER_ADDR)
308 wfMgr.setTaskDefFromFile(STORE_TASK_PATH)
309 wfMgr.setWorkflowFromFile(STORE_WF_PATH)
310 inputParam = {'input': 'fake'}
311 workflowId = wfMgr.startWorkflow(inputParam)
315 def parseLog(flag, **msg):
316 return {'result': flag, 'message': msg}
319 if __name__ == "__main__":