--- /dev/null
+#!/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