-#!/usr/bin/env python\r
-\r
-##############################################################################\r
-# Copyright (c) 2018 HUAWEI TECHNOLOGIES CO.,LTD and others.\r
-#\r
-# All rights reserved. This program and the accompanying materials\r
-# are made available under the terms of the Apache License, Version 2.0\r
-# which accompanies this distribution, and is available at\r
-# http://www.apache.org/licenses/LICENSE-2.0\r
-##############################################################################\r
-\r
-import click\r
-import os\r
-import yaml\r
-import json\r
-import collections\r
-from src.step.step_manager import TestStepManager\r
-from src.conductor_processor.workflow import WorkflowFile\r
-from conductorclient.run_new_workflow import WorkflowMgr\r
-\r
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))\r
-CONDUCTOR_SERVER_ADDR = "http://conductor_conductor-server_1:8080"\r
-STORE_TASK_PATH = "/tmp/generate_task.json"\r
-STORE_WF_PATH = "/tmp/generate_workflow.json"\r
-\r
-\r
-@click.command()\r
-@click.option("--filepath", help="file path of test case")\r
-def cmdParse(filepath):\r
- parse(filepath)\r
-\r
-\r
-def parse(filepath):\r
- filePrefix, fileName = os.path.split(filepath)\r
- print '------------ start to parse the test case:' + \\r
- '%s ----------------' % fileName\r
- with open(filepath) as f:\r
- yaml_file = yaml.load(f)\r
- parseTestcase(yaml_file['schema'], fileName)\r
-\r
- workflowId = runWorkFlow()\r
- print '------------------- parse executes end -------------------------'\r
-\r
- return workflowId\r
-\r
-\r
-def parseTestcase(schema, tcName='testcase0'):\r
- if schema is None:\r
- return parseLog(False, reason='schema not found.')\r
- steps = schema['steps']\r
- if steps is None:\r
- return parseLog(False, reason='steps is invalid.')\r
- flows = schema['flows']\r
- if flows is None:\r
- return parseLog(False, reasion='flows is invalid.')\r
- # steps is a list, step is dict. no json here.\r
- # steps = sorted(steps, sortById)\r
-\r
- # load context\r
- contextDict = {}\r
- contextDir = os.path.join(BASE_DIR, "env", "context", "context.yaml")\r
- with open(contextDir, "r") as f:\r
- contextDict = yaml.load(f)\r
- #\r
- testStepMgr = TestStepManager(contextDict)\r
-\r
- stepObjArr = []\r
- for step in steps:\r
- if 'args' not in step:\r
- step['args'] = {}\r
- # type and action can be extended, default couple is 'test' & 'start'.\r
- if 'type' not in step:\r
- step['type'] = 'test'\r
- step['action'] = 'start'\r
-\r
- stepObj = testStepMgr.getStepObj(\r
- step['type'], step['id'], step['name'], step['service'],\r
- step['action'], step['args'])\r
- stepObjArr.append(stepObj)\r
-\r
- # generate workflow by 'flow' and 'step'\r
- tcName = os.path.splitext(tcName)[0]\r
- wfFileObj = WorkflowFile(tcName)\r
- workflowDict, taskMetaList = wfFileObj.generateMetaData(flows, stepObjArr)\r
-\r
- with open(STORE_TASK_PATH, 'w') as f:\r
- f.write(json.dumps({'task_group': taskMetaList}, indent=True))\r
- with open(STORE_WF_PATH, 'w') as f:\r
- f.write(json.dumps(workflowDict, indent=True))\r
-\r
-\r
-def parseWebTestcase(webTestcase):\r
- print 'parseWebTestcase----------------------------'\r
-\r
- stepList = webTestcase['stepList']\r
- mainOrdersList = webTestcase['mainOrdersList']\r
- subflowList = webTestcase['subflowList']\r
-\r
- parseData = collections.OrderedDict()\r
- parseData['schema'] = collections.OrderedDict()\r
- parseData['schema']['steps'] = []\r
- parseData['schema']['flows'] = []\r
-\r
- parseStepList = parseData['schema']['steps']\r
- parseFlowList = parseData['schema']['flows']\r
- stepIndexDict = {}\r
- # parse stepList\r
- for index in range(len(stepList)):\r
- stepItem = stepList[index]\r
- parseStep = collections.OrderedDict()\r
-\r
- parseStep['id'] = index + 1\r
- parseStep['name'] = stepItem['name']\r
- parseStep['service'] = collections.OrderedDict()\r
- parseStep['service']['name'] = stepItem['service']\r
- parseStep['service']['interface'] = stepItem['action']\r
- parseStep['action'] = 'start'\r
- parseStep['args'] = {}\r
- for paramItem in stepItem['params']:\r
- parseStep['args'][paramItem['key']] = transParamString(\r
- paramItem['value'])\r
-\r
- parseStepList.append(parseStep)\r
- stepIndexDict[parseStep['name']] = parseStep['id']\r
- # parse flows\r
- # parse mainflow\r
- print stepIndexDict\r
- typeDict = {1: 'normal', 2: 'switch', 3: 'parallel'}\r
- mainFlow = collections.OrderedDict()\r
- mainFlow['name'] = 'main'\r
- mainFlow['orders'] = []\r
- mainFlow['orders'] = parseOrderList(\r
- mainOrdersList, stepIndexDict, typeDict)\r
- parseFlowList.append(mainFlow)\r
-\r
- # parse subflow\r
- for subflowItem in subflowList:\r
- replaceSubflow = collections.OrderedDict()\r
- replaceSubflow['name'] = subflowItem['name']\r
- replaceSubflow['orders'] = parseOrderList(\r
- subflowItem['orderList'], stepIndexDict, typeDict)\r
- parseFlowList.append(replaceSubflow)\r
-\r
- print 'END parseWebTestcase----------------------------'\r
- return parseData\r
-\r
-\r
-# parse orderlist from web edition to server edition\r
-def parseOrderList(orderList, stepIndexDict, typeDict):\r
- replaceList = []\r
- for orderItem in orderList:\r
- replaceOrder = collections.OrderedDict()\r
- orderType = typeDict[orderItem['type']]\r
- replaceOrder['type'] = orderType\r
- if orderType == 'normal':\r
- stepId = stepIndexDict[orderItem['step']]\r
- replaceOrder['step'] = stepId\r
- elif orderType == 'switch':\r
- replaceOrder['value'] = orderItem['value']\r
- replaceOrder['cases'] = collections.OrderedDict()\r
- for caseItem in orderItem['cases']:\r
- caseValue = caseItem['value']\r
- caseOrderType = caseItem['orderType']\r
- caseOrderValue = caseItem['orderValue']\r
- if caseOrderType == "step":\r
- orderInCase = collections.OrderedDict()\r
- orderInCase['type'] = 'normal'\r
- orderInCase['step'] = stepIndexDict[caseOrderValue]\r
- replaceOrder['cases'][caseValue] = [orderInCase]\r
- else:\r
- replaceOrder['cases'][caseValue] = caseOrderValue\r
- else:\r
- replaceOrder['parallel'] = collections.OrderedDict()\r
- pIndex = 1\r
- for branchItem in orderItem['branches']:\r
- pKey = 'p' + str(pIndex)\r
- branchOrderType = branchItem['orderType']\r
- branchOrderValue = branchItem['orderValue']\r
- if branchOrderType == "step":\r
- replaceBranchItem = collections.OrderedDict()\r
- replaceBranchItem['type'] = 'normal'\r
- replaceBranchItem['step'] = stepIndexDict[branchOrderValue]\r
- replaceOrder['parallel'][pKey] = [replaceBranchItem]\r
- else:\r
- replaceOrder['parallel'][pKey] = branchOrderValue\r
- pIndex += 1\r
- replaceList.append(replaceOrder)\r
- return replaceList\r
-\r
-\r
-def transParamString(val):\r
- if type(val) != str:\r
- return val\r
- if '.' not in val:\r
- if val.isdigit():\r
- return int(val)\r
- try:\r
- f = float(val)\r
- return f\r
- except ValueError:\r
- return val\r
-\r
-\r
-def getWebTestcase(originTcDict):\r
- print "getWebTestcase----------------------------------"\r
- webTcDict = {\r
- "stepList": [],\r
- "mainOrdersList": [],\r
- "subflowList": []\r
- }\r
- stepList = webTcDict['stepList']\r
- subflowList = webTcDict['subflowList']\r
- if originTcDict is None:\r
- return webTcDict\r
- originContent = originTcDict['schema']\r
- originSteps = originContent['steps']\r
- stepIndexDict = {}\r
- # transform steps to stepList\r
- for stepItem in originSteps:\r
- replaceStep = {}\r
- replaceStep['name'] = stepItem['name']\r
- replaceStep['service'] = stepItem['service']['name']\r
- replaceStep['action'] = stepItem['service']['interface']\r
- replaceStep['params'] = []\r
- if 'args' in stepItem:\r
- for (key, value) in stepItem['args'].items():\r
- replaceParam = {}\r
- replaceParam['key'] = key\r
- replaceParam['value'] = value\r
- replaceStep['params'].append(replaceParam)\r
- stepList.append(replaceStep)\r
- stepIndexDict[stepItem['id']] = stepItem['name']\r
-\r
- # transform main flow\r
- originFlows = originContent['flows']\r
- originMainflow = {}\r
- for flowIndex in range(len(originFlows)):\r
- flowItem = originFlows[flowIndex]\r
- if flowItem['name'] == 'main':\r
- originMainflow = flowItem\r
- originFlows.pop(flowIndex)\r
- break\r
- typeDict = {'normal': 1, 'switch': 2, 'parallel': 3}\r
- webTcDict['mainOrdersList'] = getOrderList(\r
- originMainflow['orders'], stepIndexDict, typeDict)\r
-\r
- # transform subflows\r
- for originSubflow in originFlows:\r
- replaceSubflow = {}\r
- replaceSubflow['name'] = originSubflow['name']\r
- replaceSubflow['orderList'] = getOrderList(\r
- originSubflow['orders'], stepIndexDict, typeDict)\r
- subflowList.append(replaceSubflow)\r
-\r
- # return web edition of testcase\r
- print "END getWebTestcase----------------------------------"\r
- return webTcDict\r
-\r
-\r
-def getOrderList(originOrderList, stepIndexDict, typeDict):\r
- replaceOrderList = []\r
- for orderItem in originOrderList:\r
- replaceOrderItem = {}\r
- orderType = orderItem['type']\r
- replaceOrderItem['type'] = typeDict[orderType]\r
- if orderType == 'normal':\r
- stepName = stepIndexDict[orderItem['step']]\r
- replaceOrderItem['step'] = stepName\r
- elif orderType == 'switch':\r
- replaceOrderItem['value'] = orderItem['value']\r
- replaceOrderItem['cases'] = []\r
- for (caseValue, ordersInCase) in orderItem['cases'].items():\r
- replaceCase = {}\r
- replaceCase['value'] = caseValue\r
- if type(ordersInCase) == list:\r
- replaceCase['orderType'] = 'step'\r
- caseStepName = stepIndexDict[ordersInCase[0]['step']]\r
- replaceCase['orderValue'] = caseStepName\r
- else:\r
- replaceCase['orderType'] = 'flow'\r
- replaceCase['orderValue'] = ordersInCase\r
- replaceOrderItem['cases'].append(replaceCase)\r
- else:\r
- replaceOrderItem['branches'] = []\r
- for paraIndex in orderItem['parallel']:\r
- paraItem = orderItem['parallel'][paraIndex]\r
- replaceBranch = {}\r
- if type(paraItem) == list:\r
- replaceBranch['orderType'] = 'step'\r
- branchStepName = stepIndexDict[paraItem[0]['step']]\r
- replaceBranch['orderValue'] = branchStepName\r
- else:\r
- replaceBranch['orderType'] = 'flow'\r
- replaceBranch['orderValue'] = paraItem\r
- replaceOrderItem['branches'].append(replaceBranch)\r
- replaceOrderList.append(replaceOrderItem)\r
-\r
- return replaceOrderList\r
-\r
-\r
-def runWorkFlow():\r
- wfMgr = WorkflowMgr(CONDUCTOR_SERVER_ADDR)\r
- wfMgr.setTaskDefFromFile(STORE_TASK_PATH)\r
- wfMgr.setWorkflowFromFile(STORE_WF_PATH)\r
- inputParam = {'input': 'fake'}\r
- workflowId = wfMgr.startWorkflow(inputParam)\r
- return workflowId\r
-\r
-\r
-def parseLog(flag, **msg):\r
- return {'result': flag, 'message': msg}\r
-\r
-\r
-if __name__ == "__main__":\r
- cmdParse()\r
+#!/usr/bin/env python
+
+##############################################################################
+# Copyright (c) 2018 HUAWEI TECHNOLOGIES CO.,LTD and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import click
+import os
+import yaml
+import json
+import collections
+from src.step.step_manager import TestStepManager
+from src.conductor_processor.workflow import WorkflowFile
+from conductorclient.run_new_workflow import WorkflowMgr
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+CONDUCTOR_SERVER_ADDR = "http://conductor_conductor-server_1:8080"
+STORE_TASK_PATH = "/tmp/generate_task.json"
+STORE_WF_PATH = "/tmp/generate_workflow.json"
+
+
+@click.command()
+@click.option("--filepath", help="file path of test case")
+def cmdParse(filepath):
+ parse(filepath)
+
+
+def parse(filepath):
+ filePrefix, fileName = os.path.split(filepath)
+ print '------------ start to parse the test case:' + \
+ '%s ----------------' % fileName
+ with open(filepath) as f:
+ yaml_file = yaml.load(f)
+ parseTestcase(yaml_file['schema'], fileName)
+
+ workflowId = runWorkFlow()
+ print '------------------- parse executes end -------------------------'
+
+ return workflowId
+
+
+def parseTestcase(schema, tcName='testcase0'):
+ if schema is None:
+ return parseLog(False, reason='schema not found.')
+ steps = schema['steps']
+ if steps is None:
+ return parseLog(False, reason='steps is invalid.')
+ flows = schema['flows']
+ if flows is None:
+ return parseLog(False, reasion='flows is invalid.')
+ # steps is a list, step is dict. no json here.
+ # steps = sorted(steps, sortById)
+
+ # load context
+ contextDict = {}
+ contextDir = os.path.join(BASE_DIR, "env", "context", "context.yaml")
+ with open(contextDir, "r") as f:
+ contextDict = yaml.load(f)
+ #
+ testStepMgr = TestStepManager(contextDict)
+
+ stepObjArr = []
+ for step in steps:
+ if 'args' not in step:
+ step['args'] = {}
+ # type and action can be extended, default couple is 'test' & 'start'.
+ if 'type' not in step:
+ step['type'] = 'test'
+ step['action'] = 'start'
+
+ stepObj = testStepMgr.getStepObj(
+ step['type'], step['id'], step['name'], step['service'],
+ step['action'], step['args'])
+ stepObjArr.append(stepObj)
+
+ # generate workflow by 'flow' and 'step'
+ tcName = os.path.splitext(tcName)[0]
+ wfFileObj = WorkflowFile(tcName)
+ workflowDict, taskMetaList = wfFileObj.generateMetaData(flows, stepObjArr)
+
+ with open(STORE_TASK_PATH, 'w') as f:
+ f.write(json.dumps({'task_group': taskMetaList}, indent=True))
+ with open(STORE_WF_PATH, 'w') as f:
+ f.write(json.dumps(workflowDict, indent=True))
+
+
+def parseWebTestcase(webTestcase):
+ print 'parseWebTestcase----------------------------'
+
+ stepList = webTestcase['stepList']
+ mainOrdersList = webTestcase['mainOrdersList']
+ subflowList = webTestcase['subflowList']
+
+ parseData = collections.OrderedDict()
+ parseData['schema'] = collections.OrderedDict()
+ parseData['schema']['steps'] = []
+ parseData['schema']['flows'] = []
+
+ parseStepList = parseData['schema']['steps']
+ parseFlowList = parseData['schema']['flows']
+ stepIndexDict = {}
+ # parse stepList
+ for index in range(len(stepList)):
+ stepItem = stepList[index]
+ parseStep = collections.OrderedDict()
+
+ parseStep['id'] = index + 1
+ parseStep['name'] = stepItem['name']
+ parseStep['service'] = collections.OrderedDict()
+ parseStep['service']['name'] = stepItem['service']
+ parseStep['service']['interface'] = stepItem['action']
+ parseStep['action'] = 'start'
+ parseStep['args'] = {}
+ for paramItem in stepItem['params']:
+ parseStep['args'][paramItem['key']] = transParamString(
+ paramItem['value'])
+
+ parseStepList.append(parseStep)
+ stepIndexDict[parseStep['name']] = parseStep['id']
+ # parse flows
+ # parse mainflow
+ print stepIndexDict
+ typeDict = {1: 'normal', 2: 'switch', 3: 'parallel'}
+ mainFlow = collections.OrderedDict()
+ mainFlow['name'] = 'main'
+ mainFlow['orders'] = []
+ mainFlow['orders'] = parseOrderList(
+ mainOrdersList, stepIndexDict, typeDict)
+ parseFlowList.append(mainFlow)
+
+ # parse subflow
+ for subflowItem in subflowList:
+ replaceSubflow = collections.OrderedDict()
+ replaceSubflow['name'] = subflowItem['name']
+ replaceSubflow['orders'] = parseOrderList(
+ subflowItem['orderList'], stepIndexDict, typeDict)
+ parseFlowList.append(replaceSubflow)
+
+ print 'END parseWebTestcase----------------------------'
+ return parseData
+
+
+# parse orderlist from web edition to server edition
+def parseOrderList(orderList, stepIndexDict, typeDict):
+ replaceList = []
+ for orderItem in orderList:
+ replaceOrder = collections.OrderedDict()
+ orderType = typeDict[orderItem['type']]
+ replaceOrder['type'] = orderType
+ if orderType == 'normal':
+ stepId = stepIndexDict[orderItem['step']]
+ replaceOrder['step'] = stepId
+ elif orderType == 'switch':
+ replaceOrder['value'] = orderItem['value']
+ replaceOrder['cases'] = collections.OrderedDict()
+ for caseItem in orderItem['cases']:
+ caseValue = caseItem['value']
+ caseOrderType = caseItem['orderType']
+ caseOrderValue = caseItem['orderValue']
+ if caseOrderType == "step":
+ orderInCase = collections.OrderedDict()
+ orderInCase['type'] = 'normal'
+ orderInCase['step'] = stepIndexDict[caseOrderValue]
+ replaceOrder['cases'][caseValue] = [orderInCase]
+ else:
+ replaceOrder['cases'][caseValue] = caseOrderValue
+ else:
+ replaceOrder['parallel'] = collections.OrderedDict()
+ pIndex = 1
+ for branchItem in orderItem['branches']:
+ pKey = 'p' + str(pIndex)
+ branchOrderType = branchItem['orderType']
+ branchOrderValue = branchItem['orderValue']
+ if branchOrderType == "step":
+ replaceBranchItem = collections.OrderedDict()
+ replaceBranchItem['type'] = 'normal'
+ replaceBranchItem['step'] = stepIndexDict[branchOrderValue]
+ replaceOrder['parallel'][pKey] = [replaceBranchItem]
+ else:
+ replaceOrder['parallel'][pKey] = branchOrderValue
+ pIndex += 1
+ replaceList.append(replaceOrder)
+ return replaceList
+
+
+def transParamString(val):
+ if type(val) != str:
+ return val
+ if '.' not in val:
+ if val.isdigit():
+ return int(val)
+ try:
+ f = float(val)
+ return f
+ except ValueError:
+ return val
+
+
+def getWebTestcase(originTcDict):
+ print "getWebTestcase----------------------------------"
+ webTcDict = {
+ "stepList": [],
+ "mainOrdersList": [],
+ "subflowList": []
+ }
+ stepList = webTcDict['stepList']
+ subflowList = webTcDict['subflowList']
+ if originTcDict is None:
+ return webTcDict
+ originContent = originTcDict['schema']
+ originSteps = originContent['steps']
+ stepIndexDict = {}
+ # transform steps to stepList
+ for stepItem in originSteps:
+ replaceStep = {}
+ replaceStep['name'] = stepItem['name']
+ replaceStep['service'] = stepItem['service']['name']
+ replaceStep['action'] = stepItem['service']['interface']
+ replaceStep['params'] = []
+ if 'args' in stepItem:
+ for (key, value) in stepItem['args'].items():
+ replaceParam = {}
+ replaceParam['key'] = key
+ replaceParam['value'] = value
+ replaceStep['params'].append(replaceParam)
+ stepList.append(replaceStep)
+ stepIndexDict[stepItem['id']] = stepItem['name']
+
+ # transform main flow
+ originFlows = originContent['flows']
+ originMainflow = {}
+ for flowIndex in range(len(originFlows)):
+ flowItem = originFlows[flowIndex]
+ if flowItem['name'] == 'main':
+ originMainflow = flowItem
+ originFlows.pop(flowIndex)
+ break
+ typeDict = {'normal': 1, 'switch': 2, 'parallel': 3}
+ webTcDict['mainOrdersList'] = getOrderList(
+ originMainflow['orders'], stepIndexDict, typeDict)
+
+ # transform subflows
+ for originSubflow in originFlows:
+ replaceSubflow = {}
+ replaceSubflow['name'] = originSubflow['name']
+ replaceSubflow['orderList'] = getOrderList(
+ originSubflow['orders'], stepIndexDict, typeDict)
+ subflowList.append(replaceSubflow)
+
+ # return web edition of testcase
+ print "END getWebTestcase----------------------------------"
+ return webTcDict
+
+
+def getOrderList(originOrderList, stepIndexDict, typeDict):
+ replaceOrderList = []
+ for orderItem in originOrderList:
+ replaceOrderItem = {}
+ orderType = orderItem['type']
+ replaceOrderItem['type'] = typeDict[orderType]
+ if orderType == 'normal':
+ stepName = stepIndexDict[orderItem['step']]
+ replaceOrderItem['step'] = stepName
+ elif orderType == 'switch':
+ replaceOrderItem['value'] = orderItem['value']
+ replaceOrderItem['cases'] = []
+ for (caseValue, ordersInCase) in orderItem['cases'].items():
+ replaceCase = {}
+ replaceCase['value'] = caseValue
+ if type(ordersInCase) == list:
+ replaceCase['orderType'] = 'step'
+ caseStepName = stepIndexDict[ordersInCase[0]['step']]
+ replaceCase['orderValue'] = caseStepName
+ else:
+ replaceCase['orderType'] = 'flow'
+ replaceCase['orderValue'] = ordersInCase
+ replaceOrderItem['cases'].append(replaceCase)
+ else:
+ replaceOrderItem['branches'] = []
+ for paraIndex in orderItem['parallel']:
+ paraItem = orderItem['parallel'][paraIndex]
+ replaceBranch = {}
+ if type(paraItem) == list:
+ replaceBranch['orderType'] = 'step'
+ branchStepName = stepIndexDict[paraItem[0]['step']]
+ replaceBranch['orderValue'] = branchStepName
+ else:
+ replaceBranch['orderType'] = 'flow'
+ replaceBranch['orderValue'] = paraItem
+ replaceOrderItem['branches'].append(replaceBranch)
+ replaceOrderList.append(replaceOrderItem)
+
+ return replaceOrderList
+
+
+def runWorkFlow():
+ wfMgr = WorkflowMgr(CONDUCTOR_SERVER_ADDR)
+ wfMgr.setTaskDefFromFile(STORE_TASK_PATH)
+ wfMgr.setWorkflowFromFile(STORE_WF_PATH)
+ inputParam = {'input': 'fake'}
+ workflowId = wfMgr.startWorkflow(inputParam)
+ return workflowId
+
+
+def parseLog(flag, **msg):
+ return {'result': flag, 'message': msg}
+
+
+if __name__ == "__main__":
+ cmdParse()
Code Review / bottlenecks.git / blobdiff