scbc_repos/ssat_sdk/utils/xml_util.py

# -*- coding:utf-8 -*-

import os
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
import xml.dom.minidom
import xml.dom
from xml.dom.minidom import parse
import json

from test_task import *
import platform_Util

def create_element(doc,tag,attr):
    elementNode = doc.createElement(tag)
    textNode = doc.createTextNode(str(attr))
    elementNode.appendChild(textNode)
    return elementNode

def saveAllResult(task, destxml):
    resultDom = xml.dom.getDOMImplementation()
    doc = resultDom.createDocument(None, "all", None)
    xsl = doc.createProcessingInstruction('xml-stylesheet', 'type="text/xsl" href="all-result.xsl"')
    root = doc.documentElement
    doc.insertBefore(xsl, root)

    #软件版本信息
    swInfoRootNode = doc.createElement(TestTask.swInfoNodeName)
    for index in range(0, task.swInfoValue.__len__()):
        hardwareNode = create_element(doc, task.swInfoKeys[index], task.swInfoValue[index])
        swInfoRootNode.appendChild(hardwareNode)
    root.appendChild(swInfoRootNode)

    #每条测试用例的结果
    allcase = task.allCase
    for tc in allcase:
        caseNode = doc.createElement(TestCase.caseNodeName)
        cnNode = create_element(doc, TestCase.cnNodeName, tc.name)
        dependNode = create_element(doc, TestCase.dependNodeName, tc.depend)
        descNode = create_element(doc, TestCase.descNodeName, tc.desc)
        scriptNode = create_element(doc, TestCase.scriptNodeName, tc.script)
        resultNode = create_element(doc, TestCase.resultNodeName, tc.result)
        detailNode = create_element(doc, TestCase.detailNodeName, tc.rdetail)
        logNode = create_element(doc, TestCase.logNodeName, tc.log)

        caseNode.appendChild(cnNode)
        caseNode.appendChild(dependNode)
        caseNode.appendChild(descNode)
        caseNode.appendChild(scriptNode)
        caseNode.appendChild(resultNode)
        caseNode.appendChild(detailNode)
        caseNode.appendChild(logNode)
        root.appendChild(caseNode)
    xmlfile = open(destxml, "w")
    doc.writexml(xmlfile, addindent=' ' * 4, newl='\n', encoding="utf-8")
    xmlfile.close()

def saveDetailResult(destxml, results):
    print "saveDetailResult"
    resultDom = xml.dom.getDOMImplementation()
    doc = resultDom.createDocument(None, Item.NODE_RESULTS, None)
    xsl = doc.createProcessingInstruction('xml-stylesheet', 'type="text/xsl" href="case_result_detail.xsl"')
    root = doc.documentElement
    doc.insertBefore(xsl, root)

    # 每条子项测试的结果
    for item in results:
        itemNode = doc.createElement(Item.NODE_ITEM)
        nameNode = create_element(doc, Item.NODE_NAME, item.name)
        resultNode = create_element(doc, Item.NODE_RESULT, item.result)
        dataNode = create_element(doc, Item.NODE_DATA, item.data)
        screenNodeList = []
        for index in range(item.screenPathList.__len__()):
            if index == Item.Screen_Max:
                break
            screenNode = create_element(doc, item.getScreenNode(), item.screenPathList[index])
            screenNodeList.append(screenNode)
        logNode = create_element(doc, Item.NODE_LOG, item.logPath)
        remarkNode = create_element(doc, Item.NODE_REMARK, item.remark)

        itemNode.appendChild(nameNode)
        itemNode.appendChild(resultNode)
        itemNode.appendChild(dataNode)
        for screenNode in screenNodeList:
            itemNode.appendChild(screenNode)
        itemNode.appendChild(logNode)
        itemNode.appendChild(remarkNode)
        root.appendChild(itemNode)
    xmlfile = open(destxml, "w")
    doc.writexml(xmlfile, addindent=' ' * 4, newl='\n', encoding="utf-8")
    xmlfile.close()

def parseDetailResult(resultxml):
    print "parseDetailResult"
    resultList = []
    if (os.path.isfile(resultxml)):
        DOMTree = xml.dom.minidom.parse(resultxml)
        rootAll = DOMTree.documentElement

        allItemNode = rootAll.getElementsByTagName(Item.NODE_ITEM)
        for itemNode in allItemNode:
            item = Item()
            nameNodes = itemNode.getElementsByTagName(Item.NODE_NAME)
            if nameNodes.__len__() > 0 and nameNodes[0].childNodes.__len__() > 0:
                nodeName = nameNodes[0].childNodes[0].nodeValue.strip()
                item.name = nodeName.encode('utf-8')
            resultNodes = itemNode.getElementsByTagName(Item.NODE_RESULT)
            if resultNodes.__len__() > 0 and resultNodes[0].childNodes.__len__() > 0:
                nodeResult = resultNodes[0].childNodes[0].nodeValue.strip()
                item.result = nodeResult.encode("utf-8")
            dataNodes = itemNode.getElementsByTagName(Item.NODE_DATA)
            if dataNodes.__len__() > 0 and dataNodes[0].childNodes.__len__()>0:
                nodeData = dataNodes[0].childNodes[0].nodeValue.strip()
                item.data = nodeData.encode('utf-8')
            nodeList = itemNode.getElementsByTagName(item.getScreenNode())
            for index in range(nodeList.__len__()):
                screenNode = nodeList[index]
                if (screenNode.childNodes.__len__() > 0):
                    desc = screenNode.childNodes[0].nodeValue.strip()
                    item.screenPathList.append(desc.encode('utf-8'))

            logNode = itemNode.getElementsByTagName(Item.NODE_LOG)[0]
            if (logNode.childNodes.__len__()>0):
                desc = logNode.childNodes[0].nodeValue.strip()
                item.logPath = desc.encode('utf-8')
            remarkNodes = itemNode.getElementsByTagName(Item.NODE_REMARK)
            if remarkNodes.__len__() > 0 and remarkNodes[0].childNodes.__len__() > 0:
                nodeRemark = remarkNodes[0].childNodes[0].nodeValue.strip()
                item.remark = nodeRemark.encode('utf-8')
            resultList.append(item)

    return resultList

def parseAllResult(resultxml):
    if (os.path.isfile(resultxml)):
        ttask = TestTask()
        DOMTree = xml.dom.minidom.parse(resultxml)
        rootAll = DOMTree.documentElement
        swInformation = rootAll.getElementsByTagName(TestTask.swInfoNodeName)
        for nodeName in ttask.swInfoKeys:
            valueNodes = swInformation[0].getElementsByTagName(nodeName)
            if (valueNodes.__len__() <= 0):
                continue
            if (valueNodes[0].childNodes.__len__() > 0):
                value = valueNodes[0].childNodes[0].nodeValue.strip()
                ttask.swInfoValue.append(value)
        print "parseAllResult,swInformation:", ttask.swInfoValue

        allcaseNode = rootAll.getElementsByTagName(TestCase.caseNodeName)
        for caseNode in allcaseNode:
            tc = TestCase()
            caseName = caseNode.getElementsByTagName(TestCase.cnNodeName)[0].childNodes[0].nodeValue.strip()
            tc.name = caseName.encode('utf-8')
            dependNode = caseNode.getElementsByTagName(TestCase.dependNodeName)[0]
            if (dependNode.childNodes.__len__() > 0):
                tc.depend = dependNode.childNodes[0].nodeValue.strip()

            descNode = caseNode.getElementsByTagName(TestCase.descNodeName)[0]
            if (descNode.childNodes.__len__() > 0):
                desc =descNode.childNodes[0].nodeValue.strip()
                tc.desc = desc.encode('utf-8')

            resultNode = caseNode.getElementsByTagName(TestCase.resultNodeName)[0]
            if (resultNode.childNodes.__len__() > 0):
                tc.result = resultNode.childNodes[0].nodeValue.strip()

            scriptNode = caseNode.getElementsByTagName(TestCase.scriptNodeName)[0]
            if (scriptNode.childNodes.__len__() > 0):
                tc.script = scriptNode.childNodes[0].nodeValue.strip()

            rdetailNode = caseNode.getElementsByTagName(TestCase.detailNodeName)[0]
            if (rdetailNode.childNodes.__len__() > 0):
                tc.rdetail = rdetailNode.childNodes[0].nodeValue.strip()

            logNode = caseNode.getElementsByTagName(TestCase.logNodeName)[0]
            if (logNode.childNodes.__len__() > 0):
                tc.log = logNode.childNodes[0].nodeValue.strip()
            print tc.name,":",tc.depend
            ttask.allCase.append(tc)
        return ttask
    return TestTask()

def correctPath(filepath):
    return filepath.replace("/", platform_Util.getFileSeprator())

def parseTask(taskpath):
    if (os.path.isfile(taskpath)):
        DOMTree = xml.dom.minidom.parse(taskpath)
        rootNode = DOMTree.documentElement

        caseFilePath=[]
        caseNodeList = rootNode.getElementsByTagName(TestTask.testCaseNameNode)
        for caseNode in caseNodeList:
            if (caseNode.hasAttribute(TestTask.caseNodeAttrFilePathLabel)):
                filePath = caseNode.getAttribute(TestTask.caseNodeAttrFilePathLabel)
                asFilePath = platform_Util.Environment.taskRootDir + platform_Util.getFileSeprator() + correctPath(filePath)
                #print "asFilePath=", asFilePath
                caseFilePath.append(asFilePath)
        return caseFilePath
    return None

def loadLocalTaskData(taskpath):
    print "[xml_util]loadLocalTaskData,taskpath=", taskpath
    taskData = TestTask()
    if (os.path.isfile(taskpath)):
        DOMTree = xml.dom.minidom.parse(taskpath)
        rootNode = DOMTree.documentElement

        caseNodeList = rootNode.getElementsByTagName(TestTask.testCaseNameNode)
        count = 0
        for caseNode in caseNodeList:
            tc = TestCase()
            tc.index = count
            if (caseNode.hasAttribute(TestTask.caseNodeAttrFilePathLabel)):
                tc.srcScript = caseNode.getAttribute(TestTask.caseNodeAttrFilePathLabel)
            if (caseNode.hasAttribute(TestTask.caseNodeAttrDescLabel)):
                tc.desc = caseNode.getAttribute(TestTask.caseNodeAttrDescLabel).encode("utf-8")
            if (caseNode.hasAttribute(TestTask.caseNodeAttrNameLabel)):
                tc.name = caseNode.getAttribute(TestTask.caseNodeAttrNameLabel).encode("utf-8")
            if (caseNode.hasAttribute(TestTask.caseNodeAttrDependLabel)):
                tc.depend = caseNode.getAttribute(TestTask.caseNodeAttrDependLabel)
            taskData.addTestCase(tc)
            count = count+1
    return taskData

def saveLocalTaskData(taskpath, taskData):
    print "[xml_util]saveLocalTaskData,taskpath=", taskpath
    taskDom = xml.dom.getDOMImplementation()
    doc = taskDom.createDocument(None, "root", None)
    root = doc.documentElement
    for tc in taskData.allCase:
        if (tc.selected == True):
            caseNode = doc.createElement(TestTask.testCaseNameNode)
            caseNode.setAttribute(TestTask.caseNodeAttrNameLabel, tc.name)
            caseNode.setAttribute(TestTask.caseNodeAttrDescLabel, tc.desc)
            caseNode.setAttribute(TestTask.caseNodeAttrFilePathLabel, tc.srcScript)
            caseNode.setAttribute(TestTask.caseNodeAttrDependLabel, tc.depend)
            root.appendChild(caseNode)
    xmlfile = open(taskpath,"w")
    doc.writexml(xmlfile, addindent=' '*4, newl='\n', encoding="utf-8")
    xmlfile.close()

def saveLocalTaskFileByCN(taskpath, taskData, cnList):
    print "[xml_util]saveLocalTaskData,taskpath=", taskpath
    taskDom = xml.dom.getDOMImplementation()
    doc = taskDom.createDocument(None, "root", None)
    root = doc.documentElement
    for cn in cnList:
        tc = taskData.getCaseByName(cn)
        print cn, ":", tc
        if (tc.selected == True):
            caseNode = doc.createElement(TestTask.testCaseNameNode)
            caseNode.setAttribute(TestTask.caseNodeAttrNameLabel, tc.name)
            caseNode.setAttribute(TestTask.caseNodeAttrDescLabel, tc.desc)
            caseNode.setAttribute(TestTask.caseNodeAttrFilePathLabel, tc.srcScript)
            caseNode.setAttribute(TestTask.caseNodeAttrDependLabel, tc.depend)
            root.appendChild(caseNode)
    xmlfile = open(taskpath,"w")
    doc.writexml(xmlfile, addindent=' '*4, newl='\n', encoding="utf-8")
    xmlfile.close()

def test_writeAllResultXml(allcase, resultxml):
    resultDom = xml.dom.getDOMImplementation()
    doc = resultDom.createDocument(None,"all", None)
    xsl = doc.createProcessingInstruction('xml-stylesheet', 'type="text/xsl" href="all-result.xsl"')
    root = doc.documentElement
    doc.insertBefore(xsl, root)

    for caseDict in allcase:
        caseNode = doc.createElement(TestCase.caseNodeName)
        cnNode = create_element(doc, TestCase.cnNodeName, caseDict[TestCase.cnNodeName])
        dependNode = create_element(doc, TestCase.dependNodeName, caseDict[TestCase.dependNodeName])
        descNode = create_element(doc, TestCase.descNodeName, caseDict[TestCase.descNodeName])
        scriptNode = create_element(doc, TestCase.scriptNodeName, caseDict[TestCase.scriptNodeName])
        resultNode = create_element(doc, TestCase.resultNodeName, caseDict[TestCase.resultNodeName])
        detailNode = create_element(doc, TestCase.detailNodeName, caseDict[TestCase.detailNodeName])
        logNode = create_element(doc, TestCase.logNodeName, caseDict[TestCase.logNodeName])

        caseNode.appendChild(cnNode)
        caseNode.appendChild(dependNode)
        caseNode.appendChild(descNode)
        caseNode.appendChild(scriptNode)
        caseNode.appendChild(resultNode)
        caseNode.appendChild(detailNode)
        caseNode.appendChild(logNode)
        root.appendChild(caseNode)
    xmlfile = open(resultxml,"w")
    doc.writexml(xmlfile, addindent=' '*4, newl='\n', encoding="utf-8")
    xmlfile.close()

def test_parseAllResult(resultxml):
    resultDom = xml.dom.minidom.parse(resultxml)
    #print resultDom.toxml()
    root = resultDom.documentElement #得到根节点
    #print root.nodeName,',',root.nodeValue,',',root.nodeType
    allcase = []
    allcaseNode = root.getElementsByTagName(TestCase.caseNodeName)
    for caseNode in allcaseNode:
        caseDict = {}
        caseName = caseNode.getElementsByTagName(TestCase.cnNodeName)[0].childNodes[0].nodeValue.strip()
        print caseName.encode('gbk')
        caseDict[TestCase.cnNodeName] = caseName.encode('utf-8')
        desc = caseNode.getElementsByTagName(TestCase.descNodeName)[0].childNodes[0].nodeValue.strip()
        caseDict[TestCase.descNodeName] = desc.encode('utf-8')
        caseDict[TestCase.resultNodeName] = \
            caseNode.getElementsByTagName(TestCase.resultNodeName)[0].childNodes[0].nodeValue.strip()
        caseDict[TestCase.scriptNodeName] = \
            caseNode.getElementsByTagName(TestCase.scriptNodeName)[0].childNodes[0].nodeValue.strip()
        caseDict[TestCase.detailNodeName] = \
            caseNode.getElementsByTagName(TestCase.detailNodeName)[0].childNodes[0].nodeValue.strip()
        caseDict[TestCase.logNodeName] = \
            caseNode.getElementsByTagName(TestCase.logNodeName)[0].childNodes[0].nodeValue.strip()
        allcase.append(caseDict)
    print allcase
    # writeAllResultXml(allcase, "all-case-1.xml")

#parseAllResult("all-case.xml")